Ubuntu-Server 9.04 installieren

Auf UTF-8 umstellen

/etc/mysql/my.cnf:

[mysqld]:

collation_server = utf8_unicode_ci
character_set_server = utf8

Webmin über den Browser konfigurieren

Thema einstellen

Sprache einstellen

Unnötige Module löschen:

z.B: ADSL-Client, CD-Brenner, Druckerverwaltung, Exim Mailserver, Heartbeat-Monitor, LILO - Boot-Konfiguration, QMail Mailserver, Sendmail Mailserver, WU-FTP FTP-Server, NIS-Client und -Server, Systemzeit, Volume-Management (LVM)

Das Systemzeit-Modul wird auch entfert, da ich das lieber direkt von Ubuntu erledigen lassen möchte. Webmin soll hier nicht rein pfuschen. Siehe weiter unten: "Zeitsynchronisation"

Postfix, Cyrus und SASL installieren und konfigurieren

aptitude install postfix postfix-doc
aptitude install sasl2-bin
aptitude install cyrus-imapd-2.2
aptitude install cyrus-pop3d-2.2
aptitude install cyrus-admin-2.2

Erklärungen zu den SASL-Postfix-Einstellungen sind unter http://www.postfix.org/SASL_README.html zu finden.

imap cmd="imapd -U 30" listen="imap" prefork=0 maxchild=100
pop3 cmd="pop3d -U 30" listen="pop3" prefork=0 maxchild=50
#nntp cmd="nntpd... (wird nicht benötigt)
lmtpunix cmd="lmtpd" listen="/var/run/cyrus/socket/lmtp" prefork=0 maxchild=20

altnamespace: yes
admins: cyrus
sieveusehomedir: false
allowplaintext: yes
sasl_pwcheck_method: auxprop
lmtpsocket: /var/run/cyrus/socket/lmtp

smtp      inet  n       -       -       -       -       smtpd -v

smtp      inet  n       -       -       -       -       smtpd

smtpd_sasl_auth_enable = yes
smtpd_sasl_local_domain = <SASL-Domäne>
smtpd_recipient_restrictions = permit_mynetworks, permit_sasl_authenticated, reject_unauth_destination
broken_sasl_auth_clients = yes

virtual_alias_domains = <Domänen die angenommen werden sollen>
virtual_alias_maps = hash:/etc/postfix/virtual
mailbox_transport = lmtp:unix:/var/run/cyrus/socket/lmtp

adduser postfix mail
adduser postfix sasl

ln /etc/sasldb2 /var/spool/postfix/etc/sasldb2

/etc/init.d/postfix restart
/etc/init.d/cyrus2.2 restart

Admin-Benutzer für Cyrus erstellen

saslpasswd2 -c cyrus

sicheres Passwort für den Benutzer vergeben und merken

Mit sasldblistusers2 kann man prüfen ob der Benutzer erfolgreich erstellt wurde und welcher Domäne er zugewiesen wurde. Diese Domäne muss in /etc/postfix/main.cf als Einstellung smtpd_sasl_local_domain gesetzt werden, falls das noch nicht passiert ist.

Test-Emailaccount erstellen und ausprobieren

Zum Testen habe ich mir die Subdomain "test.halvar.at" erstellt und auf die primäre IP-Adresse des Servers zeigen lassen. Auch der MX-Eintrag für "test.halvar.at" zeigt auf diese Adresse.

Die neue Domäne muss in /etc/postfix/main.cf eingetragen werden:

virtual_alias_domains = test.halvar.at

Damit wird der Benutzer in der SASL-DB erstellt:

saslpasswd2 -c testertest

Das Passwort wird interaktiv abgefragt.

Weiter geht's mit dem Erstellen des Postfaches:

cyradm --user cyrus localhost

localhost> cm user.testertest
localhost> setacl user.testertest testertest all   (optional, siehe Hinweis weiter unten)
localhost> quit

Mit setacl werden die Zugriffsrechte des Benutzers auf das Postfach eingestellt. Statt "all" kann man die Berechtigungen auch detaillierter angeben:

• l: Lookup (visible to LIST/LSUB/UNSEEN)
• r: Read (SELECT, CHECK, FETCH, PARTIAL, SEARCH, COPY source)
• s: Seen (STORE SEEN)
• w: Write flags other than SEEN and DELETED
• i: Insert (APPEND, COPY destination)
• p: Post (send mail to mailbox)
• c: Create and Delete mailbox (CREATE new sub-mailboxes, RENAME or DELETE mailbox)
• d: Delete (STORE DELETED, EXPUNGE)
• a: Administer (SETACL)

Jetzt muss man Postfix noch mitteilen, dass Emails an tester@test.halvar.at an das Postfach testertest übergeben werden sollen. Das kann man im Webmin mit "Postfix/Virtuelle Domänen" erledigen. Siehe:

Das erzeugt in der Datei /etc/postfix/virtual folgenden Eintrag:

tester@test.halvar.at       testertest

Man kann das jetzt weiter spinnen, indem man z.B. auch für "root" einen Eintrag erstellt und diesen über die /etc/aliases zu diesem Postfach leitet.

/etc/postfix/virtual:

root@test.halvar.at testertest

/etc/aliases:

root: root@test.halvar.at

Lesestoff

• http://spamassassin.apache.org/
• http://wiki.mobbing-gegner.de/Linux/SpamAssassin/Links (deutsche Links)
• http://wiki.debianforum.de/PostfixSpamassassinCyrus
• http://wiki.apache.org/spamassassin/UsingSpamAssassin
• http://wiki.apache.org/spamassassin/ThirdPartySoftware
• http://www.oreilly.de/german/freebooks/spamvirger/ (deutsches Buch)
• http://wiki.apache.org/spamassassin/IntegratedInPostfixWithAmavis

Spamassassin-Server aktivieren und konfigurieren

Spamassassin läuft zwar auch als einfaches Kommandozeilenprogramm, aber schneller geht's als Server (spamd).

ENABLED=1
CRON=1

report_safe 0

Spamassassin-Benutzer erstellen

Mit diesem Befehl wird ein Benutzer erstellt, der sich nicht einloggen kann, da ein "!" als Passwort eingestellt wird.

adduser spamassassin

Spamassassin speichert Einstellungen im Home-Ordner dieses Benutzers und das Programm spamc wird in dessen Kontext ausgefürt.

Spamassassin in Postfix integrieren

smtp            inet  n       -       -       -       -       smtpd
    -o content_filter=spamassassin

spamassassin    unix  -       n       n       -       -       pipe
    user=spamassassin
    null_sender=
    argv=/usr/bin/spamc -e /usr/sbin/sendmail -oi -f ${sender} ${recipient}

Spam automatisch in einen eigenen IMAP-Ordner verschieben

Zuerst muss ein entsprechender IMAP-Ordner für den Benutzer erstellt werden.

cyradm --user cyrus localhost

localhost> cm user.testertest.Spam
localhost> quit

Dann muss man eine Textdatei mit der Sieve-Regel erstellen. Diese wird dann mit dem Programm sievehell in den Sieve-Ordner des Benutzers kopiert und aktiviert.

mkdir /etc/sieve_templates
touch /etc/sieve_templates/spam

/etc/sieve_templates/spam:

require "fileinto";

if header :contains "X-Spam-Level" "******" {
    fileinto "Spam";
    stop;
}

Mehr Informationen über Sieve-Regeln bekommst du hier:

• http://www.ietf.org/rfc/rfc3028.txt
• http://cyrusimap.web.cmu.edu/twiki/bin/view/Cyrus/SpecificationsAndStandards#sieve.txt

Mit dem Programm sieveshell kopiert man nun die Vorlage in den Sieve-Ordner des Benutzers:

sieveshell --user=testertest --authname=cyrus localhost

Man wird nach dem Passwort für den Cyrus-Benutzer gefragt.

> put /etc/sieve_templates/spam
> activate spam
> quit

Das Programm sieveshell kann auch mit einem Skript als Parameter aufgerufen werden. Siehe man sieveshell.

Programm: copy_to_ftp.py

Dieses kleine Programm kopiert die letzten Sicherungen zum Backup-FTP-Server von Hetzner. Das Programm ist einfach aufgebaut. Man muss nur ein paar Konstanten anpassen und die Passwörter für den FTP-Zugang und zum Verschlüsseln der Sicherungen in zwei Textdateien hinterlegen.

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import os
import ftplib
from cStringIO import StringIO
import subprocess
import tempfile

FTP_HOST = "<IP-Adresse des FTP-Backup-Servers>"
FTP_USER = "<Benutzername fuer den FTP-Backup-Server>"
FTP_PASS_FILE = os.path.join(os.path.dirname(os.path.abspath(__file__)), "ftppasswd")
FTP_PASS = file(FTP_PASS_FILE, "r").readline().strip()
CCRYPT_PASS_FILE = os.path.join(os.path.dirname(os.path.abspath(__file__)), "ccryptpasswd")
PLACEHOLDER = "_placeholder"
CCRYPT = "/usr/bin/ccrypt"

MYSQL_SOURCE_DIR = "/backup/mysql"
MYSQL_SOURCE_CURRENT_FILE = "/backup/mysql/.current"
MYSQL_DEST_DIR = "mysql"
MYSQL_DEST_CURRENT_FILE = "current"
MYSQL_DEST_MAX_BACKUPS = 10

FILES_SOURCE_DIR = "/backup/files"
FILES_SOURCE_CURRENT_FILE = "/backup/files/.current"
FILES_DEST_DIR = "files"
FILES_DEST_CURRENT_FILE = "current"
FILES_DEST_MAX_BACKUPS = 2


def copy_to_ftp(
    source_dir, source_current_file, dest_dir, dest_current_file, dest_max_backups
):
    # Verbinden
    ftp = ftplib.FTP(FTP_HOST, FTP_USER, FTP_PASS)

    # Platzhalter-Datei im Root-Ordner erstellen/ueberscheiben
    ftp.storbinary("STOR %s" % os.path.join("/", PLACEHOLDER), StringIO())

    # Basisordner erstellen
    if (
        os.path.join("/", dest_dir) not in
        (os.path.join("/", item) for item in ftp.nlst("/"))
    ):
        ftp.mkd(dest_dir)

    # Platzhalter-Datei im Basis-Ordner erstellen/ueberscheiben
    ftp.storbinary(
        "STOR %s" % os.path.join("/", dest_dir, PLACEHOLDER),
        StringIO()
    )

    # QUELLE Current-Datei auslesen
    source_current = int(file(source_current_file, "r").readline().strip())

    # ZIEL Current-Datei auslesen
    dest_current_file_path = os.path.join("/", dest_dir, dest_current_file)
    if dest_current_file_path in ftp.nlst(os.path.join("/", dest_dir)):
        current_file = StringIO()
        ftp.retrbinary("RETR %s" % dest_current_file_path, current_file.write)
        current_file.seek(0)
        try:
            dest_current = int(current_file.readline().strip()) + 1
        except ValueError:
            dest_current = 1
    else:
        dest_current = 1
    if dest_current > dest_max_backups:
        dest_current = 1

    # Pfade herausfinden
    full_source_dir = os.path.join(source_dir, str(source_current))
    full_dest_dir = os.path.join("/", dest_dir, str(dest_current))

    # Zielordner löschen
    if full_dest_dir in ftp.nlst(os.path.join("/", dest_dir)):
        for full_filename in ftp.nlst(full_dest_dir):
            ftp.delete(full_filename)
        ftp.rmd(full_dest_dir)

    # Zielordner und Platzhalter-Datei erstellen
    ftp.mkd(full_dest_dir)
    ftp.storbinary(
        "STOR %s" % os.path.join(full_dest_dir, PLACEHOLDER),
        StringIO()
    )

    # Dateien des Quellordner durchlaufen
    for filename in os.listdir(full_source_dir):
        # Verbindung schliessen
        try:
            ftp.quit()
            ftp.close()
        except: pass

        # Pfade
        full_source_filename = os.path.join(full_source_dir, filename)
        full_dest_filename = os.path.join(full_dest_dir, filename + ".cpt")

        print "Copy to FTP:", full_source_filename

        # Datei verschluesseln
        tmp_file = tempfile.TemporaryFile()
        args = [CCRYPT, "--encrypt", '--keyfile=%s' % CCRYPT_PASS_FILE]
        proc = subprocess.Popen(
            args, stdout = tmp_file, stdin = file(full_source_filename, "rb"),
            stderr = subprocess.PIPE
        )
        (stdout_str, stderr_str) = proc.communicate()
        if stderr_str:
            for line in stderr_str.splitlines():
                print "    ", line.rstrip()

        # Verbindung neu oeffnen
        ftp = ftplib.FTP(FTP_HOST, FTP_USER, FTP_PASS)

        # Datei in den Zielordner kopieren
        tmp_file.seek(0)
        ftp.storbinary("STOR %s" % full_dest_filename, tmp_file)
        tmp_file.close()

    # Ziel Current-Datei erstellen/ueberschreiben
    current_file = StringIO()
    current_file.write(str(dest_current))
    current_file.seek(0)
    ftp.storbinary("STOR %s" % dest_current_file_path, current_file)

    # Platzhalter-Dateien entfernen
    try:
        ftp.delete(os.path.join(full_dest_dir, PLACEHOLDER))
    except ftplib.error_perm:
        pass
    try:
        ftp.delete(os.path.join(dest_dir, PLACEHOLDER))
    except ftplib.error_perm:
        pass
    try:
        ftp.delete(os.path.join("/", PLACEHOLDER))
    except ftplib.error_perm:
        pass

    # Fertig
    try:
        ftp.quit()
        ftp.close()
    except: pass


def copy_mysql():
    copy_to_ftp(
        MYSQL_SOURCE_DIR, MYSQL_SOURCE_CURRENT_FILE, MYSQL_DEST_DIR,
        MYSQL_DEST_CURRENT_FILE, MYSQL_DEST_MAX_BACKUPS
    )


def copy_files():
    copy_to_ftp(
        FILES_SOURCE_DIR, FILES_SOURCE_CURRENT_FILE, FILES_DEST_DIR,
        FILES_DEST_CURRENT_FILE, FILES_DEST_MAX_BACKUPS
    )


def main():
    # Letzte MYSQL-Sicherung zum FTP-Server kopieren
    copy_mysql()

    # Letzte FILES-Sicherung zum FTP-Server kopieren
    copy_files()


if __name__ == "__main__":
    main()

chown root:root ftppasswd
chmod 600 ftppasswd

chown root:root ccryptpasswd
chmod 600 ccryptpasswd

Programm: backup_mysql.py

Dieses Programm liest aus, welche Datenbanken es gibt und sichert jede Datenbank in eine eigene Dump-Datei (SQL). Die Sicherungen werden mit gzip gepackt. Nach den mit MAX_BACKUPS eingestellten Sicherungen wird die älteste Sicherung überschrieben.

#!/usr/bin/env python
# coding: utf-8

import os
import sys
import subprocess
import shutil
import stat


MAX_BACKUPS = 50
BACKUP_DIR = "/backup/mysql"
CURRENT_FILE = "/backup/mysql/.current"
MYSQL_ROOTPW_FILE = os.path.join(
    os.path.dirname(os.path.abspath(__file__)), "mysqlrootpasswd"
)
MYSQL = "/usr/bin/mysql"
MYSQLDUMP = "/usr/bin/mysqldump"
GZIP = "/bin/gzip"


def main():
    # MySQL-Root-Passwort auslesen
    password = file(MYSQL_ROOTPW_FILE, "r").readline().strip()

    # Current-Datei auslesen
    if os.path.isfile(CURRENT_FILE):
        try:
            current = int(file(CURRENT_FILE, "r").readline().strip()) + 1
        except ValueError:
            current = 1
    else:
        current = 1
    if current > MAX_BACKUPS:
        current = 1

    # Pfad für Sicherung
    dest_dir = os.path.join(BACKUP_DIR, str(current))
    if os.path.isdir(dest_dir):
        shutil.rmtree(dest_dir, ignore_errors = True)
    os.makedirs(dest_dir)
    os.chmod(BACKUP_DIR, stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR)
    os.chmod(dest_dir, stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR)

    args = [MYSQL, "--user=root", "--password=%s" % password]
    proc = subprocess.Popen(args, stdin = subprocess.PIPE, stdout = subprocess.PIPE)
    proc.stdin.write("SHOW DATABASES;")
    proc.stdin.close()
    proc.stdout.readline()
    for line in proc.stdout:
        dbname = line.strip()
        print "Backup:", dbname

        # Dateiname zusammensetzen
        sql_file_name = os.path.join(dest_dir, dbname + ".sql")

        # Sichern
        cmd = MYSQLDUMP + ' --user="root" --password="%s" %s > %s'
        cmd = cmd % (password, dbname, sql_file_name)
        os.system(cmd)

        # Zippen
        cmd = GZIP + " %s" % sql_file_name
        os.system(cmd)

    # Current-Datei neu schreiben
    f = file(CURRENT_FILE, "w")
    f.write(str(current))
    f.close()


if __name__ == "__main__":
    main()

chown root:root mysqlrootpasswd
chmod 600 mysqlrootpasswd

Programm: backup_files.py

Dieses Programm sichert alle Ordner, die in der Konstante SOURCE_PATHS angegeben werden, in den Zielordner (BACKUP_DIR). Nach den mit MAX_BACKUPS eingestellten Sicherungen wird die älteste Sicherung überschrieben.

Zum Sichern wird tar verwendet.

#!/usr/bin/env python
# coding: utf-8

import os
import sys
import subprocess
import shutil
import stat


TAR = "/bin/tar"
MAX_BACKUPS = 7
BACKUP_DIR = "/backup/files"
CURRENT_FILE = "/backup/files/.current"
SOURCE_PATHS = [
    "/etc",
    "/home",
    "/root",
    "/scripts",
    "/var/log",
    "/var/spool",
]


def main():
    # Current-Datei auslesen
    if os.path.isfile(CURRENT_FILE):
        try:
            current = int(file(CURRENT_FILE, "r").readline().strip()) + 1
        except ValueError:
            current = 1
    else:
        current = 1
    if current > MAX_BACKUPS:
        current = 1

    # Pfad für Sicherung
    dest_dir = os.path.join(BACKUP_DIR, str(current))
    if os.path.isdir(dest_dir):
        shutil.rmtree(dest_dir, ignore_errors = True)
    os.makedirs(dest_dir)
    os.chmod(BACKUP_DIR, stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR)
    os.chmod(dest_dir, stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR)

    # Ordner sichern
    for path in SOURCE_PATHS:
        print "Backup:", path

        # Dateiname zusammensetzen
        file_name = os.path.join(
            dest_dir, path.replace(os.sep, "_")[1:] + ".tar.gz"
        )

        # Sichern
        args = [TAR, "--create", "--file=%s" % file_name, "--gzip", path]
        proc = subprocess.Popen(
            args, stdout = subprocess.PIPE, stderr = subprocess.STDOUT
        )
        for line in proc.stdout:
            if not (
                "Removing leading" in line or
                "socket ignored" in line
            ):
                print "    ", line.rstrip()

    # Current-Datei neu schreiben
    f = file(CURRENT_FILE, "w")
    f.write(str(current))
    f.close()


if __name__ == "__main__":
    main()

Tägliche Sicherung aller Dateien inkl. Datenbanken

Diese Sicherung sollte, auf Grund der doch recht massiven Arbeit, die beim Sichern vom Server zu verrichten ist, nur einmal am Tag durchgeführt werden. Am Besten dann, wenn der Server sowiso kaum ausgelastet ist.

Zuerst müssen die Dateien gesichert und dann zum SQL-Server übertragen werden. Danach werden die Datenbanken gesichert und ebenfalls zum SQL-Server übertragen. Ich habe dafür ein kleines Skript geschrieben, welches von Cron täglich in der Nacht ausgeführt wird.

#!/usr/bin/env python
# coding: utf-8

import backup_files
import backup_mysql
import copy_to_ftp


def main():

    # Dateien sichern und zum FTP-Server übertragen
    backup_files.main()
    copy_to_ftp.copy_files()

    # MySQL-Datenbanken sichern und zum FTP-Server übertragen
    backup_mysql.main()
    copy_to_ftp.copy_mysql()


if __name__ == "__main__":
    main()

SHELL=/bin/sh
PATH=/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin
MAILTO=root

...

# Taegliches Backup
50 1 * * *      root    /scripts/backup_full_daily.py

# Vereinzelte MySQL-Backups
43 10 * * *      root    /scripts/backup_mysql.py
43 16 * * *      root    /scripts/backup_mysql.py

man 5 crontab

Backup-Benutzer erstellen

Dazu muss man zuerst von "root" zum "postgres"-Benutzer wechseln:

su - postgres

Als "postgres"-Benutzer kann man sich jetzt an die DB anmelden:

psql localhost

Im psql-Programm kann man nun mit folgenden Befehlen einen Backup-Benutzer erstellen und das Passwort vergeben:

CREATE USER backupuser WITH SUPERUSER;
\password backupuser

Man wird nun nach dem Passwort des backupuser-Benutzers gefragt.

Passwortdatei

Man kann an die im Backup-Programm benötigten Kommandozeilenprogramme psql und pg_dump kein Passwort direkt als Parameter übergeben (was auch gut ist). Stattdessen kann man mit Hilfe der Umgebungsvariable PGPASSFILE den Pfad zu einer Textdatei übergeben, die das Passwort enthält.

Die Textdatei /scripts/pgpassfile muss folgende Struktur aufweisen:

hostname:port:database:username:password

Das sieht bei mir z.B. so aus:

localhost:*:*:backupuser:DasPasswort

Dann sollte man sich noch darum kümmern, dass niemand außer root auf die Datei zugreifen kann:

cd /scripts
chown root:root pgpassfile
chmod 600 pgpassfile

Das Programm /scripts/backup_postgresql.py:

#!/usr/bin/env python
# coding: utf-8

import os
import sys
import subprocess
import shutil
import stat


MAX_BACKUPS = 50
BACKUP_DIR = "/backup/postgresql"
CURRENT_FILE = "/backup/postgresql/.current"
BACKUP_USER = "backupuser"
PGPASSFILE = os.path.join(
    os.path.dirname(os.path.abspath(__file__)), "pgpassfile"
)
PSQL = "/usr/bin/psql"
PG_DUMP = "/usr/bin/pg_dump"
GZIP = "/bin/gzip"


def main():
    # Umgebungsvariable PGPASSFILE
    os.environ["PGPASSFILE"] = PGPASSFILE

    # Current-Datei auslesen
    if os.path.isfile(CURRENT_FILE):
        try:
            current = int(file(CURRENT_FILE, "r").readline().strip()) + 1
        except ValueError:
            current = 1
    else:
        current = 1
    if current > MAX_BACKUPS:
        current = 1

    # Pfad für Sicherung
    dest_dir = os.path.join(BACKUP_DIR, str(current))
    if os.path.isdir(dest_dir):
        shutil.rmtree(dest_dir, ignore_errors = True)
    os.makedirs(dest_dir)
    os.chmod(BACKUP_DIR, stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR)
    os.chmod(dest_dir, stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR)

    args_db = [
        PSQL, "--username=%s" % BACKUP_USER, "--dbname=postgres", "--tuples-only",
        "--command=SELECT datname FROM pg_database WHERE (datname NOT LIKE 'template_');"
    ]
    proc_db = subprocess.Popen(args_db, stdout = subprocess.PIPE)
    for line in proc_db.stdout:
        dbname = line.strip()
        if not dbname:
            continue
        print "Backup:", dbname

        # Dateiname zusammensetzen
        sql_file_name = os.path.join(dest_dir, dbname + ".sql")

        # Sichern
        args_dump = [
            PG_DUMP, "--encoding=utf-8", "--no-owner", "--username=%s" % BACKUP_USER,
            "--format=plain", "--file=%s" % sql_file_name,  dbname
        ]
        proc_dump = subprocess.Popen(args_dump)
        proc_dump.communicate()

        # Zippen
        cmd = GZIP + " %s" % sql_file_name
        os.system(cmd)

    # Current-Datei neu schreiben
    f = file(CURRENT_FILE, "w")
    f.write(str(current))
    f.close()


if __name__ == "__main__":
    main()

Apache-Module aktivieren

Im Ordner mods-available sind die Konfigurationen und Ladeanweisungen für die installierten Apache-Module abgelegt. Möchte man ein Modul aktivieren, dann verlinkt man die zum gewünschten Modul gehörenden Dateien in den mods-enabled-Ordner. Beim Verlinken sollte man absolute Pfade verwenden.

Ich finde es einfacher ln -s zu verwenden als immer wieder nach dem dafür vorgesehenen Apache-Programm zu suchen. Ja, das gibt es. Es heißt -- warte, ich muss mal nachsehen -- a2enmod. :-)

IP-Adresse(n) und Port(s) des Apache-Servers einstellen

Dafür ist die Datei /etc/apache2/ports.conf zuständig. Hier wird eingestellt, an welchen IP-Adressen und Ports der Apache als Server arbeiten soll. Diese Datei sieht bei mir im Moment so aus:

Listen 188.40.88.80:80
NameVirtualHost 188.40.88.80:80

<IfModule mod_ssl.c>
    # SSL name based virtual hosts are not yet supported, therefore no
    # NameVirtualHost statement here
    Listen 188.40.88.80:443
</IfModule>

Eines ist aber klar: sie wird sich im Laufe der weiteren Konfiguration auf jeden Fall noch ändern.

Apache-Sites

Man kann für jede virtuelle Domäne eine Konfigurationsdatei erstellen. Diese legt man in den Ordner sites-available. Verlinkt man die Konfigurationsdatei mit einem symbolischen Link in den Ordner sites-enabled, dann wird die Konfiguration nach einem Neustart des Apachen aktiv. Zum Verlinken kann man ln -s, oder das Apache-Programm a2ensite verwenden. Nimmt man ln -s, dann kann man zusätzlich den Namen (und somit die Sortierung) der Links bestimmen.

Die Datei /etc/apache2/sites-available/default muss man kaum verändern. Man sollte aber die Emailadresse des Server-Admins korrekt einstellen.

Virtuelle Testdomäne erstellen

Für die Emails habe ich mir bereits die Testdomäne test.halvar.at eingerichtet. Sie zeigt auf die IP-Adresse des neuen Servers. Diese kann jetzt auch zum Testen des Apachen verwendet werden.

Zuerst erstelle ich den Linux-Benutzer test_halvar_at und folgende zugehörigen Ordner:

• /home/test_halvar_at/awstats
• /home/test_halvar_at/public
• /home/test_halvar_at/public/cgi-bin.
• /home/test_halvar_at/log
• /home/test_halvar_at/webalizer

Der public-Ordner wird der Root-Ordner der Website. Dann erstelle ich dort noch die Datei index.html und schreibe "Hallo Welt - test.halvar.at" rein. Das genügt um später feststellen zu können, ob der Apache die richtige Datei ausliefert.

Dann erstelle ich die Konfigurationsdatei für die Testdomäne. Ich kopiere mir dazu die default-Datei und passe sie nach meinen Vorstellungen an.

#
# test.halvar.at
#
<VirtualHost 188.40.88.80:80>

    ServerAdmin gerold.penz@aon.at

    ServerName test.halvar.at
    ServerAlias www.test.halvar.at

    DocumentRoot /home/test_halvar_at/public

    <Directory /home/test_halvar_at/public>
        Order allow,deny
        Allow from all
        Options Indexes MultiViews
        IndexOptions FancyIndexing VersionSort HTMLTable NameWidth=* FoldersFirst XHTML
        AddDefaultCharset utf-8
        AllowOverride All
    </Directory>

    <Directory /home/test_halvar_at/public/cgi-bin>
        AllowOverride None
        Options +ExecCGI -Indexes -MultiViews
        Order allow,deny
        Allow from all
        AddHandler cgi-script .cgi .pl .py
    </Directory>

    # Possible values include: debug, info, notice, warn, error, crit, alert, emerg.
    LogLevel info
    ErrorLog /home/test_halvar_at/log/apache_error.log
    CustomLog /home/test_halvar_at/log/apache_access.log combined

</VirtualHost>

a2ensite test_halvar_at
/etc/init.d/apache2 stop
/etc/init.d/apache2 start

cd /home/test_halvar_at/public/cgi-bin
touch hallowelt.py
chmod +x hallowelt.py

#!/usr/bin/env python
# coding=utf-8

import time

print "Content-type: text/plain"
print
print "Hallo Welt!"
print
print "Es ist jetzt %s Uhr." % time.strftime("%H:%M:%S")

Hallo Welt!

Es ist jetzt 20:53:34 Uhr.

/etc/apache2/conf.d/security:

ServerTokens Prod
ServerSignature Off

/etc/logrotate.d/homedirs:

/home/*/log/*.log {
    weekly
    missingok
    rotate 52
    compress
    delaycompress
    notifempty
    create 640 root root
    sharedscripts
    postrotate
        if [ -f "`. /etc/apache2/envvars ; echo ${APACHE_PID_FILE:-/var/run/apache2.pid}`" ]; then
            /etc/init.d/apache2 reload > /dev/null
        fi
    endscript
}

/etc/apache2/mods-available/wsgi.load:

Das ist die Datei zum Einbinden des Modules in den Apachen.

LoadModule wsgi_module /usr/lib/apache2/modules/mod_wsgi.so

Nach dem Erstellen der Datei kann man das neue Modul mit folgendem Befehl einbinden:

a2enmod wsgi

Jabber

Jabber auf dem Server installieren. Da fast alles Fischer auf dem Server sind, könnte das so eine Art Fischer-Chat werden.

Mögliche Clients:

• Gajim (http://de.wikipedia.org/wiki/Gajim)
• Pidgin (http://de.wikipedia.org/wiki/Pidgin_%28Instant_Messenger%29)

Web-cyradm

...