Home  |  Map  |  Index  |  Zoek

Convert to GutenPalm or to PalmDoc door Erdal Mutlu <erdal(at)linuxfocus.org> Over de auteur: Erdal is een van de Turkse LF auteurs. Hij werkt op dit moment als systeembeheerder bij de Linotype Library. Hij is al een grote Linux fan vanaf dat hij op de universiteit zat, hij houdt van werken en ontwikkelen in deze omgeving. Vertaald naar het Nederlands door: Hendrik-Jan Heins <hjh(at)passys.nl> Inhoud: Inleiding Waarom SSH gebruiken? Bestanden en Mappen Copieren met SCP Extern Aanmelden met behulp van SSH Commando's Uitvoeren met Behulp van SSH Verbinding Maken met een Externe Computer zonder Wachtwoord Het Script Eenvoudig een Backup maken van je configuratie bestanden Conclusie Bronnen Talkback voor dit artikel

Systeembeheer automatiseren met SSH en SCP

Kort:

Wanneer je veel Linux systemen beheert, heb je zeker enkele scripts nodig die je helpen bij het automatiseren van enkele processen. Je zult tijdens je dagelijkse werk gemerkt hebben dat je op veel systemen ongeveer dezelfde handelingen uitvoert. Misschien hebt je er al eens aan gedacht om deze processen op een of andere manier te automatiseren. Dit is vooral handig bij het onderhoud aan veel identieke Linux/Unix systemen. In dit artikel laat ik een manier zien om dit te doen met SSH gereedschappen.

Inleiding

Om dit artikel te begrijpen moet je wat basiskennis over commandoregel programmeren hebben. Voor meer informatie over commandoregel programmeren, kan je het LinuxFocus Commandoregel Programmeren artikel van Katja en Guido Socher bekijken. Je hebt ook enige kennis van SSH gereedschappen zoals SSH-keygen, SSH-add, SSH, SCP en SFTP nodig. Er bestaat een gratis versie van SSH voor Linux: OpenSSH, die al deze gereedschappen bevat. Er zijn ook man-pagina's beschikbaar.

Waarom SSH gebruiken?

Bestanden en Mappen Copieren met SCP

scp /path/to/the/file/file1 user@remote_host:/remotedir/newfile

scp user@remote_host:/remotedir/file /path/to/local/folder/newfile

scp -r user@remote_host:/remotedir .

Opmerking: Er wordt aangenomen dat je een SSH daemon hebt draaien op het externe systeem.

Extern Aanmelden met behulp van SSH

ssh erdal@helvetica.fonts.de

Commando's Uitvoeren met Behulp van SSH

ssh erdal@helvetica.fonts.de df -H

Verbinding Maken met een Externe Computer zonder Wachtwoord

ssh-keygen -b 1024 -t dsa

Om je sleutel te kunnen gebruiken, moet je de publieke sleutel op de externe machine installeren. De inhoud van het publieke sleutelbestand moet worden gecopieerd naar $HOME/.ssh/authorized_keys of $HOME/.ssh/authorized_keys2 file. Wees wel voorzichtig en mix geen sleutels voor verschillende protocol versies. authorized_keys wordt gebruikt voor protocol versie 1. authorized_keys2 wordt gebruikt voor protocol versie 2. Wanneer je de publieke sleutel correct hebt geïnstalleerd, word je de eerste keer dat je verbinding maakt met die machine, gevraagd om je wachtzin op te geven en wanneer je het fout doet word je gevraagd het wachtwoord voor de externe gebruiker op te geven. Je kunt de verbinding beperken zodat er standaard alleen gebruik wordt gemaakt van autorisatie op basis van de publieke sleutel door het configuratie bestand van SSHd aan te passen. De bestandsnaam is /etc/ssh/sshd_config en de instelling die je moet wijzigen is 'PasswordAuthentication'. Verander de waarde van deze instellig naar "no" (PasswordAuthentication no) en herstart SSHd.

Tot dit punt gaat alles goed. We hebben een veilige manier om bestanden te copieren en uit te voeren op externe systemen. Maar, voor de automatisering van sommige taken zou het handig zijn als we geen wachtwoorden hoefden in te geven. Anders valt er niets te automatiseren. Een oplosing kan zijn het opgeven van het wachtwoord in ieder script, maar dt is niet echt een goed idee. De betere methode is het gebruiken van de key-agent voor de wachtwoorden. SSH-agent is een programma dat private sleutels beheert om publieke sleutels te autoriseren. Start nu een key-agent:

ssh-agent $BASH

ssh-add .ssh/id_dsa

ssh-add .ssh/identity

ssh-add -l

Als je nu een verbinding maakt met een server die jouw sleutel heeft in z'n autorisatie bestand, krijg je een verbinding zonder een letter in te typen! De SSH-agent handelt het autorisatieproces af.

Wanneer je een SSH-agent op de bovenstaande manier gebruikt, kan je hem alleen gebruiken in het venster waarin de SSH-agent is gestart, daarna moet je nog wat werk verzetten als je hem ook in andere vensters wilt gebruiken. Ik heb het volgende kleine script geschreven om de SSH-agent te starten:

#!/bin/sh
#
# Erdal mutlu
#
# Starting an ssh-agent for batch jobs usage.

agent_info_file=~/.ssh/agent_info

if [ -f $agent_info_file ]; then
 echo "Agent info file : $agent_info_file exists."
 echo "make sure that no ssh-agent is running and then delete this file."
 exit 1
fi

ssh-agent | head -2 > $agent_info_file
chmod 600 $agent_info_file
exit 0

Het bovenstaande script controleert of er al een bestand bestaat dat agent_infoheet in de persoonlijke map van de gebruiker op de plaats waar normaal gesproken SSH gerelateerde bestanden staan. In ons geval is dat de map '.ssh/'. Als het bestand bestaat, wordt de gebruiker gewaarschuwd dat het er al is en wordt er melding gemaakt van de mogelijkheden. Wanneer de gebruiker geen draaiende SSH-agent heeft, dan moet hij/zij het bestand verwijderen en het script nogmaals starten. Het script start de SSH-agent en schrijft de eerste twee regels naar het bestand agent_info Deze informatie kan achteraf door de SSH gereedschappen gebruikt worden. Vervolgens stat er een regel om de modus van het bestand te veranderen, zodat alleen de eigenaar van het bestand het kan lezen en er naar kan schrijven.

Wanneer de SSH-agent draait, kan je je sleutels eraan toevoegen. Maar voordat je dt doet, moet je "source" starten met het bestand agent_info, zodat de SSH gereedschappen weten waar de SSH-agent is:

source ~/.ssh/agent_info or . ~/.ssh/agent_info

En voeg je sleutels toe met SSH-add. Je kunt de volgende regels toevoegen aan je .bashrc bestand zodat iedere keer dat je een terminal venster opent, het bestand agent_info automatisch wordt "ge-sourced":

if [ -f .ssh/agent_info ]; then
. .ssh/agent_info
fi

WAARSCHUWING: Je moet de machine waario je de SSH-agent en het geautomatiseerde script dat ik hieronder ga beschrijven wel goed beveiligen. Anders heeft iemand die toagang heeft tot jou account ook toegang tot alle servers waarvn je de SSH sleutels hebt. Alles heeft z'n prijs...

Het Script

Nu wordt het tijd om uit te leggen hoe we enkele systeem beheer taken gaan automatiseren. Het gaat erom een aantal commando's uit te voerenvoor een bepaalde lijst machines en om enkele bestanden te halen of te sturen nar deze machines. Dit moet een systeembeheerder regelmatig doen. Hier is het script:

#!/bin/sh

# Installing anything using Secure SHELL and SSH agent
# Erdal MUTLU
# 11.03.2001


##################################################################
#                     Functions                                  #
##################################################################
### Copy files between hosts
copy_files()
{
 if [ $files_file != "files_empty.txt" ];then
  cat $files_file | grep -v "#" | while read -r line
  do
   direction=`echo ${line} | cut -d " " -f 1`
   file1=`echo ${line}     | cut -d " " -f 2`
   file2=`echo ${line}     | cut -d " " -f 3`

   case ${direction} in
      "l2r") :	### From localhost to remote host
          echo "$file1  --> ${host}:${file2}"
          scp $file1 root@${host}:${file2}
      ;;
      "r2l") :	### From remote host to localhost
          echo "${host}:${file2}  --> localhost:${file2}"
          scp root@${host}:${file1} ${file2}
      ;;
      *)
          echo "Unknown direction of copy : ${direction}"
          echo "Must be either local or remote."
      ;;
   esac
  done
 fi
}

### Execute commands on remote hosts
execute_commands()
{
 if [ $commands_file != "commands_empty.txt" ];then
  cat $commands_file | grep -v "#" |  while read -r line
  do
   command_str="${line}"
   echo "Executing $command_str ..."
   ssh -x -a root@${host}  ${command_str} &
   wait $!
   echo "Execute $command_str OK."
  done
 fi
}

### Wrapper function to execute_commands and copy_files functions
doit()
{
 cat $host_file | grep -v "#" | while read -r host
 do
  echo "host=$host processing..."
  case "${mode}" in
	"1")
		copy_files
		execute_commands
		;;
	"2")
		execute_commands
		copy_files
		;;
	*)
		echo "$0 : Unknown mode : ${mode}"
		;;
  esac
  echo "host=$host ok."
  echo "------------------------------------------------------------------"
 done
}

##################################################################
### Program starts here
##################################################################

if [ $# -ne 4 ]; then
 echo "Usage : $0 mode host_file files_file commands_file"
 echo ""
 echo "mode is 1 or 2 "
 echo "    1 : first copy files and then execute commands."
 echo "    2 : first execute commands and then copy files."
 echo "If the name of files.txt is files_empty.txt then it is not processed."
 echo "If the name of commands.txt is commands_empty.txt then it is
 echo "not processed."
 exit
fi


mode=$1
host_file=$2
files_file=$3
commands_file=$4

agent_info_file=~/.ssh/agent_info
if [ -f $agent_info_file ]; then
 . $agent_info_file
fi

if [ ! -f $host_file ]; then
 echo "Hosts file : $host_file does not exist!"
 exit 1
fi

if [ $files_file != "files_empty.txt" -a ! -f $files_file ]; then
  echo  "Files file : $files_file does not exist!"
  exit 1
fi

if [ $commands_file != "commands_empty.txt" -a ! -f $commands_file ]; then
 echo  "Commands file : $commands_file does not exist!"
 exit 1
fi

#### Do everything there
doit

We bewaren het script als ainstal.sh (geautomatiseerde installatie) en proberen het te starten onder parameters. We krijgen het volgende bericht:

./ainstall.sh

Usage : ./ainstall.sh mode host_file files_file commands_file

mode is 1 or 2
        1 : first copy files and then execute commands.
        2 : first execute commands and then copy files.
If the name of files.txt is files_empty.txt then it is not processed.
If the name of commands.txt is commands_empty.txt then it is not
processed.

Zoals het bericht al weergeeft: als je geen commando's wilt uitvoeren, geef dan commands_empty.txt op als bestandsnaam voor commands.txt en wanneer je geen bestanden wilt versturen, geef dan files_empty.txt aan als naam voor files_file. Soms hoef je alleen maar enkele commando's uit te voeren, terwijl je een andere keer alleen bestanden wilt versturen.

Voordat ik het script regel voor regel ga uitleggen, is hier een voorbeeld van gebruik: Stel dat je een tweede DNS server hebt toegevoegd aan je netwerk en dat je deze wilt toevoegen aan het /etc/resolv.conf bestand. Ga er voor het gemak van uit dat alle machines hetzelfde /etc/resolv.conf bestand bevatten. Het enige dat je nu hoeft te doen is het nieuwe resolv.conf bestand copieren naar alle machines.
allereerst heb je een lijst van alle machines nodig. We gaan alle machines opgeven in een bestand geheten hosts.txt. Het format van het hosts.txt bestand vereist dat iedere machine op een nieuwe regel wordt aangegeven, met of de naam of het IP adres. Hier is een voorbeeld:

##########################################################################
#### Every line contains one hostname or IP address of a host. Lines that
#### begin with or contain # character are ignored.
##########################################################################
helvetica.fonts.de
optima.fonts.de
zaphino
vectora
#10.10.10.162
10.10.10.106
193.103.125.43
10.53.103.120

Zoals je kan zien in het voorbeeld, kan je volledige machinenamen aangeven of alleen het eerste deel. Daarna heb je een bestand nodig waar je de te sturen bestanden in beschrijft. Er zijn twee mogelijkheden:

• De eerste mogelijkheid is een transfer van de lokale machine naar de machines die zijn aangegeven in het bestand hosts.txt. Dit is wat we in ons geval gaan doen.
• Vanaf iedere machine die is aangegeven in het bestand hosts.txt naar de lokale machine. Dit is om van iedere machine bestanden te verkrijgen. Bijvoorbeeld voor het gebruik met ons eenvoudige backup script, dat ik later in dit artikel zal beschrijven.

De te verzenden bestanden zijn aangegeven in een ander bestand. Dit slaan we op als files_file.txt. Het format van het bestand is als volgt: iedere regel bevat informatie over een te copieren bestand. Er zijn twee mogelijke copieer richtingen: 12r (lokaal naar extern) en r2l (extern naar lokaal). l2r is wanneer een bestand wordt gecopieerd van de lokale machine naar een externe machine. r21 is wanneer een bestand wordt gecopieerd van een externe macne naar de lokale machine. na het richtingscommando komen de bestandsnamen. Velden worden gescheiden door een spatie of een tab. Het eerste bestand wordt gecopieerd naar het tweede volgens het richtingscommando. De bestandsnaam voor de externe mchine moet volledig worden aangegeven, anders wordt het gecopieerd naar de persoonlijke map van de extern ingelogde gebruiker (root meestal). Hier is ons files_file.txt bestand:

############################################################################
# The structure of this file is :
# - The meaning of the fileds are : is l2r (localhost to remote) and r2l
# (remote computer to local).
#       r2l  file1   file2
#         means copy file1 from remote (hosts specified in the
#         hosts.txt file) computer to localhost as file2.
#       l2r     file1   file2
#         means copy file1 from localhost to
#         remote (hosts specified in the hosts.txt file) computer as file2
#         file1 and file2 are files on the corrsponding hosts.
#
#       Note: the order of using local and remote specifies the direction
#       of the copy process.
############################################################################
l2r     resolv.conf     /etc/resolv.conf

Zoals je kunt zien heb ik al een omschrijving van hoe de structuur vn het bestand in elkaar zit bijgeleverd. Normaal gesproken lever ik deze beschrijving bij ieder files_file.txt bestand dat ik gebruik. Het is een eenvoudige maar goede manier van documenteren. In ons voorbeeld willen we het bestand resolv.conf copieren naar een externe machine als /etc/resolv,conf. Ter demonstratie heb ik commando's om de eigenaar en de groep te veranderen bijgevoegd en laat ik het bestand /etc/resolv.conf zien na het copieren. Commando's die moeten worden uitgevoerd, moeten in een afzonderlijk bestand geplaatst worden. We noemen ht bestand met de commando's "commands_file.txt". Hier is ons commands_file.txt bestand:

###########################################################################
# The structure of this file is : Every line contains a command to be
#  executed. Every command is treated seperately.
###########################################################################
chown root.root /etc/resolv.conf
chmod 644 /etc/resolv.conf
cat /etc/resolv.conf

Het commando's bestand bevat commando's die op iedere externe machine die is aangegeven in het hosts.txt bestand worden uitgevoerd. De Commando's worden sequentieel (achter elkaar) uitgevoerd, dus het eerste commando's wordt als eerste uitgevoerd, daarna het tweede enz.

Okay, nu heb je alle benodigde bestanden voor dit eenvoudige voorbeeld. Het enige dat nog moet worden aangegeven is de "modus" optie, deze geeft aan welke van de twee bestanden, commands_file.txt of files_file.txt, als eerste moet worden uitgevoerd. Je kunt de bestanden die zijn aangeven in files_file.txt eerst versturen en daarna alle commando's uitvoeren op de aangegeve machines, dit is mode=1. Maar je kunt ook eerst de commando's uitvoeren en daarna de bestanden sturen, dat i mode=2. Nu kan je het script als volgt met de juiste argumenten starten:

./ainstall.sh 1 hosts.txt files_file.txt commands_file.txt

Een kleine tip: ik begin files.txt normaal gesproken altijd met files_een kleine omschrijving, zoals bijvoorbeeld "files_resolvconf.txt. Ik doe hetzelfde met hosts.txt en commands.txt.

Nu is het tijd om wat uit te leggen over het script zelf. Het programma begint met het controleren van het aantal argumenten; wanneer dit geen 4 is, wordt het gebruiksbericht getoond. Wanneer het aantal argumenten klopt, worden de argumenten toegewezen aan de bijbehorende variabelen. Daarna, wordt "source" uitgevoerd wanneer het bestand '~/.ssh/agent_info' bestaat. Dit bestand bevat informatie over de draaiende SSH agent. Wanneer je geen agent draait, moet je de wachtwoorden handmatig ingeven, dus geen automatisering ;-). Daarna wordt er van ieder bestand (hosts, files en commands) nagegaan of het bestaat. Er bestat ook een speciale test voor files_empty.txt en commands_empty.txt. Wanneer je een dergelijke naam hebt aangegeven, is controle op het bestaan van het bestand niet nodig. Ik heb dit deel van het script veranderd tijdens het schrijven van dit artikel. Voorheen was het:

if [ -f $host_file -a -f $files_file -a -f $commands_file ]; then
 echo "$host_file $files_file $commands_file"
 doit
else
 echo "$host_file or $files_file or $commands_file does not exist"
 exit
fi

In dit geval moest ik bestanden hebben met de namen: files_empty.txt en commands_empty.txt. Maar dit was helemaal geen probleem aangezien ik maar in een map werkte.
Aan het einde komt de aanroep naar de functie 'doit'. Alles wordt geregeld met deze functie. De functie bevat een loop die bestaat uit 'cat' en 'while', die voor iedere aangegeven externe machine in het '$hosts_file' de copy_files en execute_commands functies aanroept volgens de 'mode'. Dus voor iedere externe machine wordt het werk zo gedaan. De 'host' variabele bevat de huidige naam of het IP adres van de externe machine.
Laten we eens kijken naar de copy_files functie. Deze functie controleert eerst of de waarde van 'files_file' gelijk is aan die van 'files_empty.txt' of niet. Wanneer de waarde gelijk is, gebeurt er niets. Wanneer de waarde niet gelijk is, dan wordt voor iedere regel in '$files_file', 'direction', 'file1' en 'file2' de variabelen die de richting van de copie bepalen, respectievelijk de eerste en de tweede bestandsnaam volgens de waarde van de 'direction' variabele, gecopieerde met behulp van scp.
Laten we tenslotte eens kijken naar de execute_commands functie. De functie controleert of de waarde van het 'commands_file' gelijk is aan 'commands_empty.txt'. Wanneer de waarde hetzelfde is, gebeurt er niets. Wanneer de waarde niet hetzelfde is, dan wordt ieder commando in '$commands_file' in de achtergrond uitgevoerd op de externe machine met behulp van SSH. Na het uitvoeren van het SSH commando wordt er een pauze aangeroepen met de parameter '$!'. Dit commando zorg ervoor dat ieder commando in sequentiele vorm wordt uitgevoerd. '$!' vergroot het procesnummer met het meest recentelijk uitgevoerde achtergrond commando.
Dat is alles, eenvoudig, niet?

Eenvoudig een Backup maken van je configuratie bestanden

Hier is een geavanceerder voorbeeld gebruik van het script. Het gaat erom een backup te maken van de configuratie bestanden van je externe machines of servers. Hiervoor heb ik een klein script geschreven dat ainstall.sh gebruikt:

#!/bin/sh

server_dir=${HOME}/erdal/sh/ServerBackups

if [ ! -d $server_dir ]; then
 echo "Directory : $server_dir does not exists."
 exit 1
fi

cd $server_dir

servers=ll_servers.txt
prog=${HOME}/erdal/sh/einstall_sa.sh

cat $servers | grep -v "#" | while read -r host
do
  echo $host > host.txt
  $prog 1 host.txt files_empty.txt
  servers/${host}/commands_make_backup.txt
  $prog 1 host.txt files_getbackup.txt commands_empty.txt
  mv -f backup.tgz servers/${host}/backup/`date +%Y%m%d`.tgz
  rm -f host.txt
done

exit 0

Je moet een speciale map hebben die servers heet. In deze map moeten twee bestanden staan: files_getbackup.txt en ll_servers.txt. Hier is 'files_getbackup.txt' :

r2l /root/backup.tgz backup.tgz

'll_servers.txt' bevat de namen of IP adressen van de externe machines die ge-backupt dienen te worden. Iedere naam in het bestand 'll_servers.txt' moet een map bevatten met dezelfde naam en in die map moet een bestand genaamd commands_make_backups.txt staan, dat een commando bevat om een /root/backup.tgz archief van de configuratie bestanden te maken van die machine. En een map genaamd backup. Ale backups van deze machine worden in die map opgeslagen. Wanneer de inhoud van ll_servers.txt het volgende is:

fileserver
dbserver
10.10.10.1
appserver

Dan is de mappen structuur van je '$servers' map als volgt:

servers
|-- files_getbackup.txt
|-- ll_servers.txt
|-- make_server_backups.sh
|-- 10.10.10.1
|   |-- backup
|   `-- commands_make_backup.txt
|-- appserver
|   |-- backup
|   `-- commands_make_backup.txt
|-- dbserver
|   |-- backup
|   `-- commands_make_backup.txt
|-- fileserver
    |-- backup
    `-- commands_make_backup.txt

En hier zijn enkele voorbeelden voor de commands_make_backups.txt bestanden:

tar cfz /root/backup.tgz /etc/samba /etc/atalk /etc/named.conf /var/named/zones

Het bovenstaande commands_make_backup.txt wordt gebruikt om een backup te maken van samba, atalk en nameserver instellingen en zone bestanden.

tar cfz /root/backup.tgz /etc/httpd /usr/local/apache

Het bovenstaande commands_make_backup.txt wordt gebruikt om een backup te maken van apache server instellingen en bestanden.

tar cfz /root/backup.tgz /etc/squid /etc/named.conf

Het bovenstaande commands_make_backup.txt wordt gebruikt om eenn backup te maken van de squid proxy server en secondaire dns server instellingen.

Door de bovenstaande scripts te gebruiken en commands_make_backup.txt bestanden te maken zoals jij ze nodig hebt, kan je backups van de instellingen van je servers maken.

Conclusie

Bronnen

• SSH, The Secure Shell: The Definitive Guide, by Daniel J. Barrett and Richard Silverman.
• Door de tunnel, van Georges Tarbouriech.
• Commandoregel programmeren, van Katja en Guido Socher.

Talkback voor dit artikel

2003-01-19, generated by lfparser version 2.31