Beginnen wir mit einem einfachen VBS-Script um ein Netzlaufwerk zu verbinden unter Windows. Ich weiss die gibts wie Sand am Meer, aber meines ist besser

'Author: 	Patrick schmid
'Datum:	23.9.2008
'Version:	1.0.0

Option Explicit

'Variablen einlesen
Dim objNetwork, objFSO
Dim strPath, strDrive, bolPer, strUsr, strPas

'Neue Systemojekte kreieren
Set objNetwork = CreateObject("WScript.Network")
Set objFSO = CreateObject("Scripting.FileSystemObject")

'Relevante Daten definieren
strPath = "\\PFAD\ZUM\SERVER'
strDrive = "W:"
bolPer = False
strUsr = "USER"
strPas = "PASSWORD"

'Prüfen ob Drive schon vorhanden
If NOT objFSO.DriveExists (strDrive) Then
	'drive mappen
	objNetwork.MapNetworkDrive strDrive, strPath , bolPer, strUsr, strPas
End If

Oder noch ein VBS-Script, um zwei DNS-Einträge zu setzen:

'-----------------------------------------------------------------------------------------------
'Author:		Patrick Schmid
'Date:			14.12.2009
'Version:		1.0
'-----------------------------------------------------------------------------------------------
Option Explicit

'reserve variabels
Dim objWMIService, colNetCards, arrDNSServers, objNetCard, strprimary, strsecondary

'set dns ips for primary and secondary
strprimary = "192.168.1.18"
strsecondary = "192.168.1.19"

'set array with primary and secondary dns server
arrDNSServers = Array(strprimary, strsecondary)

'get system environment
Set objWMIService = GetObject("winmgmts:{impersonationLevel=impersonate}!\\.\root\cimv2")

'get all Network interfaces
Set colNetCards = objWMIService.ExecQuery("Select * From Win32_NetworkAdapterConfiguration Where IPEnabled = True")

'read each network interface in variable
For Each objNetCard in colNetCards
	'set dns arry to network interface
	objNetCard.SetDNSServerSearchOrder(arrDNSServers)
Next

Nun weg von der dunklen Seite – auf zu Linux, da hab ich entsprechend mehr Material

Los geht es mit einem Perl-Script, welches alle Benutzer aus dem LDAP ausliesst, die abgelaufen sind und diese via eMail informiert:

#!/usr/bin/perl -w
use IPC::Open3;
use Net::LDAP;

$date = setExpire();
my $LDAPHOST = "";
my $LDAPROOT  = "";
my $LDAPUPASS = "";

my $ldap = Net::LDAP->new($LDAPHOST) or die "Can't bind to ldap:\n $!\n $@";
$ldap->bind;
my $pid = open3(\*IN,\*OUT,0,'/bin/bash');
my $cmd = 'lsuser -a expires ALL > tmpusers';
print IN "$cmd\n";
open(USERS, "tmpusers") || die("tmpusers is not accessable!");
@raw_data = <USERS>;
close(USERS);
foreach $user (@raw_data)
{
	@splited = split(/=/, $user);
	@splited2 = split(/ /, $splited[0]);
	$username = $splited2[0];
	if (not($splited[1] == "0"))
	{
		$exyear = (substr($splited[1],8,2));
		$exmonth = (substr($splited[1],0,2));
		$exday = (substr($splited[1],2,2));
		$expired = "$exyear$exmonth$exday";
		if ($date > $expired) {
			my $pid = open3(\*IN,\*OUT,1,'/bin/bash');
			my $cmd = 'lsuser -a gecos '.$username;
			print IN "$cmd\n";
			my $result = <OUT>;
			if ((index($result,"gecos")) > 0)
			{
				@raw_info = split(/=/, $result);
				if ((index($raw_info[1],"_")) > 0)
				{
					@raw_name = split(/_/, $raw_info[1]);
					$fullname = $raw_name[0]." ".$raw_name[1];
				} else {
					$fullname = $raw_info[1];
				}
				my ($mesg) = $ldap->search(
					base   => "ou=People,$LDAPROOT",
					filter => "(uid=$username)",
					attrs => ['uid', 'mail']
				);
				$mesg->code && die $mesg->error;
				foreach my $entry ( $mesg->entries ) {
					my ($useremail) = $entry->get_value('mail');
					my $pid = open3(\*IN,\*OUT,1,'/bin/bash');
					my $cmd = '/usr/lib/sendmail -t
						To: '.$useremail.'
						Subject: Account has expired
						Dear '.$fullname.'
						Your account '.$username.' has expired!';
					print IN "$cmd\n";
				}
			}
		}
	}
}

$ldap->unbind;

sub setExpire {
	my ($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) = localtime(time);

	$year += 1900;
	$mon += 1;
	$year = sprintf("%02d", $year % 100);
	$mon = sprintf("%02d", $mon % 100);
	$mday = sprintf("%02d", $mday% 100);
	return "$year$mon$mday";
}

Oder ein Bash-Script, um einen Drucker hinzuzufügen:

#!/bin/bash
echo "What's the printer's name?"
read printer
echo "What's the queue's name (Default: $printer)?"
read queue

echo "<Printer $printer>" >> /etc/cups/printers.conf
echo "Info $printer" >> /etc/cups/printers.conf
echo "DeviceURI lpd://$printer/$queue" >> /etc/cups/printers.conf
echo "State Idle" >> /etc/cups/printers.conf
echo "Accepting Yes" >> /etc/cups/printers.conf
echo "JobSheets none none" >> /etc/cups/printers.conf
echo "QuotaPeriod 0" >> /etc/cups/printers.conf
echo "PageLimit 0" >> /etc/cups/printers.conf
echo "KLimit 0" >> /etc/cups/printers.conf
echo "</Printer>" >> /etc/cups/printers.conf

echo "restarting cups"
/etc/init.d/cups restart

Wie wäre es mit einem kleinen Script, dass den freien Festplattenspeicher mit ASCII grafisch aufbereitet:

#!/bin/bash
df -h $1 | tr -s ' ' '\t' | cut -f2,3,5,6 | grep '^[^/].*$' | grep '^.*/.*$' | while read all use pct fs
	#get the percent without the % and wirte it to fil
	do echo $pct $fs | cut -d% -f1 | while read fil
		#write as that much # as the number of fil is
		do for (( i=0 ; $i<$fil; i=$i+1 ))
			#write everything to out
			do out="$out#"
		done

		#calculate the rest
		rest=$((100-fil))
		for (( i=0 ; $i<$rest; i=$i+1 ))
			#add everything to out too
			do out="$out-"
		done

		#get the size of the mountpoint
		size=$(echo $fs | wc -m)
		#calculate the needed rest
		size=$((15-$size))

		#add the number of spaces
		for (( i=0 ; $i<$size; i=$i+1 ))
			do space="$space "
		done

		#print the mountpoint, space buffer and out (its fil)
		echo -e "$fs $space $out $pct ($use/$all)"
	done
done

Oder aber ein Script (benötigt expect) das via iLO eine Maschine neustartet:

#!/usr/bin/expect
# Version 1.0
# by Patrick Schmid

spawn ssh root@[lindex $argv 0]
expect "Password:" {send "PASSWORD\r"}
expect "> " {send "reset /SYS -script\r"}
expect {
	"Performing" {puts stdout "\nDone"}
  default {puts stdout "\nError"}
}

So jetzt mal weg von den Scripts, einfach ein paar Befehle für die Konsole. So zum Hinzufügen einer Maschine zu einer NIS-Domäne:

ypset -d DOMÄNE SERVER
/etc/init.d/ypbind restart
chkconfig --level 345 ypbind on

Oder eine Checkliste zum Zurücksetzen eines vergessenen Passwortes unter RedHat:

• Insert de Rescue Disk
• Befor loading the system press F2 to enter the start up menu
• Select Disk and wait until it is loaded
• Press F5 to enter rescue mode
• enter “linux rescue” and confirm with Enter
• Wait until a shell promt comes up
• Type “chroot /mnt/syslinux” and confirm with enter
• mount -o remount,rw /
• Open the shadow file by entering “vi /etc/shadow”
• Delete the value between the first two :
• Type :wq to save and quit
• Type shutdown -h now and remove the CD
• Password is reseted now

Auch die Quota lässt sich ganz einfach anzeigen und anpassen:

zfs get quota store/home/USERNAME
zfs set quota=10G store/home/USERNAME

Oder aber viel Nützliches im Umgang mit SUN / Solaris. So zum Beispiel zum Ausführen eines Filesystemchecks:

fsck -v ufs /dev/dsk/c0t0d0sX

Oder zum sauberen Neustarten eines Maschine:

sync:sync:reboot

Oder wenn man auf der Konsole mit BACKSPACE nichts mehr löschen kann, so hilft:

stty erase [BACKSPACE]

Auch wenn man alle Partitionen sehen will, wird geholfen:

echo|format

Oder wer von der Konsole aus neustarten will:

boot -s (Single User)
boot net -s (ab Netzwerk starten)
boot net - install (ab Netzwerk installieren)
boot cdrom -s (von CD starten)

Auch wer unter Solaris sein Passwort vergisst, muss nicht verzweifeln:

• boot cdrom -s –> Ab CD starten
• echo|format –> Die Partitionen ausgeben
• mkdir /tmp/d –> Ordner zum mounten erstellen
• mount /dev/dsk/c0t0d0s0 /tmp/t –> Partition mounten
• vim /etc/shadow –> Passwortfile öffnen, Passwort für root löschen
• sync;sync;reboot –> Reboot
• fsck /dev/dsk/c0t0d0s0 –> file system check
• fsck -y /dev/dsk/c0t0d0s0 –> confirm file system check

So das war es dann in etwa auch schon wieder. Und ja ich weiss, die Scripts sind teils schrecklich umständlich, aber sie führten zum Ziel

Also will ich mich mal ans repetieren machen und beginne mit DNS, genauer Bind9 einrichten und konfigurieren. Später folgen dann nach und nach noch all die anderen Themen, wodurch eine Artikelserie daraus werden wird.

Doch zuerst zu DNS! Obwohl eigentlich sollte man es eher als Namensauflösung bezeichnen, denn es werden noch Dienste wie NIS oder Dateien wie /etc/hosts angesprochen.

Aber alles von vorne! Also die einfachste Möglichkeit zum eine IP-Adresse auflösen ist über die Hosts-Datei unter /etc/hosts. Diese könnte in etwa so aussehen:

root@master:/etc# cat /etc/hosts
127.0.0.1	localhost
127.0.1.1	master.encodingit.ch	master

# The following lines are desirable for IPv6 capable hosts
::1     ip6-localhost ip6-loopback
fe00::0 ip6-localnet
ff00::0 ip6-mcastprefix
ff02::1 ip6-allnodes
ff02::2 ip6-allrouters

Jedoch wenn man mehr als nur ein, zwei Computer hat, so ist es relativ mühsam auf jedem diese Datei von Hand zu pflegen. Auch Sun bemerkte dies und entwickelte NIS (darüber habe ich schon mal geschrieben).
Doch als auch das nicht mehr reichte, kam man zu DNS.
Einfach gesagt ist es eine Hosts-Datei, welche an einem zentralen Ort verwaltet werden kann und von jeder Maschine bei Bedarf geladen wird. Komplizierter gesagt: dazu kommen wir noch

Die wichtigsten Dateien für die Namensauflösung auf einem Client wären dabei:

/etc/hosts > verantwortlich für die lokale Namensauflösung.
/etc/resolv.conf > gibt an, welche Nameserver angefragt und welche Domains durchsucht werden sollen.
/etc/nsswitch.conf > definiert die Reihenfolge ob zuerst der DNS, NIS oder die Hosts-Datei bei der Auflösung berücksichtigt werden soll.

Dies war alles auf dem Client – nun aber zu unserem DNS Server. Zuerst mal installieren:

apt-get install bind9

Gestartet wird der Dienst entweder über /usr/sbin/named oder über /etc/init.d/bind9 (unter Debian). Doch nach der Installation läuft er sowieso standardmässig.

Die Konfiguration ist ganz amüsant! LPIC will sich ja nicht auf eine Distribution festlegen, deshalb gibt es bei einem typischen Beispiel wie bind immer wieder Unterschiede.
Unter Debian (unter welchem ich die Installationen gerade durchführe) liegt alles wie gewohnt unter /etc/bind. RedHat oder Suse packen die Konfigurationsdateien aber in /etc/named.conf und die Zonendateien in /var/named. Viel Spass beim Suchen

Unter Debian läuft die Konfiguration von Bind und der Zonen in zwei einzelnen Files ab:

named.conf.options > Darin werden alle Einstellungen definiert, wie sich der DNS-Server zu verhalten hat
named.conf.local > Hier werden all die Einstellungen zu den Zonen definiert

Nun wollen wir aber auch unser erstes Zonen-File anlegen.
Zuerst der Forward Lookup von Domain -> IP. Dazu legen wir eine Datei in das Verzeichnis /etc/bind mit dem Namen unserer Domain:

touch /etc/bind/encodingit.ch

Diese befüllen wir nun mit dem DNS-Syntax, welcher sehr akribisch eingehalten werden muss:

$TTL 2d
@ IN SOA master.encodingit.ch. root.encodingit.ch. (
               2011030401       ; serial
               3h               ; refresh
               1h               ; retry
               1w               ; expiry
               1d )             ; minimum

@              IN NS   master.encodingit.ch.
master          IN A    192.168.1.20

Die Datei ist bei jeder Zone immer gleich aufgebaut. Auf der ersten Zeile wird die Time-To-Life festgelegt, Dann folgen Angaben über den DNS und die Email-Adresse des Admins (mit . anstatt @). Weiter geht es mit einer eindeutigen Nummer, Standardangaben und dann endlich die eigentlichen Lookups.
Zuerst wird ein NS-Record für die Domain angelegt, danach wird der Name über einen A-Record einer IP zugewiesen.

Nun müssen wir noch den Reverse Lookup einrichten. Dazu machen wir wieder eine neue Datei:

touch /etc/bind/1.168.192.in-addr.arpa

Und befüllen auch diese:

$TTL 2d
@ IN SOA master.encodingit.ch. root.encodingit.ch. (
               2011030401       ; serial
               3h               ; refresh
               1h               ; retry
               1w               ; expiry
               1d )             ; minimum

@     IN NS master.encodingit.ch.
20	   IN PTR		master.encodingit.ch.

Nachdem die Zonen nun angelegt sind, muss man den DNS auch noch dazu zwingen, diese zu kennen. Dazu muss die named.conf.local mit einem Eintrag wie dem folgenden ergänzt werden:

zone "encodingit.ch" {
type master;
file "/etc/bind/encodingit.ch";
};

zone "1.168.192.in-addr.arpa" {
type master;
file "/etc/bind/1.168.192.in-addr.arpa";
};

Nun muss noch bind neu gestartet und dann der Client auf den neuen DNS gewechselt werden:

/etc/init.d/bind9 restart
echo "domain encodingit.ch" > /etc/resolv.conf
echo "nameserver 127.0.0.1" >> /etc/resolv.conf

Und schon ist der DNS bereit!

Für mich war das eine Premiere, da ich bisher nur unter Windows das vergnügen hatte, und da ist es wirklich keine grosse Sache.

Umso erstaunter war ich, wie kompliziert das eigentlich unter Linux ist…

Doch war ich irgendwie zu faul (oder einfach vom WindowsGUI verwöhnt), alle Dateien einzeln zu editieren und konfigurieren, also habe ich auf Webmin zurückgegriffen.

Webmin erlaubt es, viele Einstellungen in Bereichen wie Netzwerkverwaltung, Useradministration, Servereinstellungen und vieles mehr direkt über ein GUI im Browser zu konfigurieren.

Zuerst muss man sich also das aktuelle Paket von Sourceforge holen:

wget http://downloads.sourceforge.net/project/webadmin/webmin/1.390/webmin_1.390_all.deb

Danach kann man die Installation starten:

sudo dpkg -i webmin_*

Da aber noch einige Pakete fehlen, wird die Installation vorerst fehlschlagen. Also gilt es dies noch zu berichtigen:

sudo apt-get install -f

Und nun ist Webmin auch schon installiert unter unter https://127.0.0.1:10000 verfügbar.

Jetzt kann also die Installation losgehen. Dazu ruft man Webmin auf und loggt sich mit einem User ein, welcher sudo-Rechte besitzt.
Dann wählt man unter “Server” den Punkt “BIND DNS Server”.

Nun muss man zuerst mal eine neue Zone erstellen. Hierfür wählt man den Punkt “Create master zone”. Will man, wie in meinem Fall Namen zu IPs auflösen, so muss man eine Forward Lookup Zone erstellen.

Unter “Domain name / Network” vergibt man den Namen für die Zone. Dieser wird auch gleich der Name der Top Level Domain sein (zB. lokal, ch oder com).
Nun muss man noch unter “Email address” eine eMail-Adresse eingeben. Der Rest kann man auf den Standardeinstellungen belassen.

Jetzt kann man endlich die ersten Namen einer IP zuordnen. Dazu definiert man alle Namen und IPs unter dem Punkt “Address (0)”.

Wenn man will, kann man unter “Reverse Address (0)” nochmal die selbigen Informationen zuordnen.

Nachdem man seine Änderungen abgespeichert hat, kann man die Einstellungen testen.
Dazu logge ich mich per SSH ein und führe eine Abfrage an den DNS Server aus:

dig @127.0.0.1 name.domain

Eine Antwort sollte etwa so aussehen:

; <<>> DiG 9.4.2-P2 <<>> @127.0.0.1 name.domain
; (1 server found)
;; global options: printcmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 18355
;; flags: qr aa rd ra; QUERY: 1, ANSWER: 1, AUTHORITY: 1, ADDITIONAL: 0

;; QUESTION SECTION:
;name.domain. IN A

;; ANSWER SECTION:
name.domain. 38400 IN A 192.168.0.1

;; AUTHORITY SECTION:
domain. 38400 IN NS SL004.

;; Query time: 1 msec
;; SERVER: 127.0.0.1#53(127.0.0.1)
;; WHEN: Sun Nov 29 01:52:00 2009
;; MSG SIZE rcvd: 62

Nun muss man nur noch den einzelnen Hosts den DNS hinzufügen. Da bei mir alle Clients ihre IPs per DHCP beziehen, musste ich den DNS nur da eintragen, und abwarten.

Und von nun an, muss ich mir keine mühsamen IP-Adressen mehr merken
Vielen Dank an Roman für die Tipps zu Webmin.