Skripting av faste rutiner sparer oss for masse tid og hodebry.
Skripting innebærer at vi lager små eller store tekstfiler med kommandoer og programlogikk som automatiserer små og store rutiner vi utfører ofte.
Det kan være backup, filoverføringer, sjekke status for kataloger, sjekke antall filer, utplassere(deploy) ny versjoner på server, kjøre testversjoner og mye mer.
Å lage gode og sikre skript kan gjøre repetetive oppgaver mye enklere og raskere å utføre enn å gjøre det manuelt hver eneste gang. Det er «nesten ingen grenser» for hvor avansert et skript kan bli.
Det anbefales sterkt å lære seg skripting for å automatisere og effektivisere arbeidet.
Lage et skript med nano
Står i egen hjemmekatalog:
brukernavn@servernavn:~$ nano test_skript
Elementer i skriptet
Linje 1 er obligatorisk. Skript starter med:
#!/bin/bash
Linje 2 er ikke obligatorisk, og kun et eksempel på en kommentar. Som linje 1 er linje 2 i dette aktuelle skriptet kommentert ut med grindtegnet: #
#test_skript
Linje 3 er kommando echo som dette skriptet skal kjøre for å vise et eksempel:
echo «Tester skripting!»
Når skriptet kjøres vil kommandoen echo printe Tester skripting! på terminalens output. Før det kan skje må skriptet gjøres kjørbart.
Gjøre skriptet kjørbart
Alle skript plasseres i katalogen ~/bin. Katalogen ~/bin har filrettighet drwxrwx— eller 770.
(Dersom katalogen ~/bin ikke finnes, kan den opprettes med kommando $ mkdir bin)
Skriptets filrettighet endres til 700 med chmod.
Det betyr at eier av hjemmekatalogen har alle rettigheter til å kjøre filen, mens gruppe og andre ikke har noen rettigheter.
Nå kan vi kjøre filen ved å kalle på den når vi står i ~/bin.
brukernavn@servernavn:~/bin$ test_skript
Tester skripting!
Vi kan også kalle på skriptet når vi står i roten av vår hjemmekatalog:
brukernavn@servernavn:~$ test_skript
Tester skripting!
I Ubuntu kan det hende at man må logge av og på igjen for at ~/bin skal legge seg i systemvariabelen $PATH.
Det kan skje dersom et skript i ~/bin ikke gjenkjennes som kommando.
Man kan også legge /bin i $PATH slik:
export PATH=»$HOME/bin:$PATH»
Et eksempel
Her er et konkret eksempel.
Bruk av eksempelet forutsetter at det er mulig å koble til en remote host (en annen server) med ssh nøkler. Det må derfor distribueres public key til remote host fra vår egen server. Se f eks How to Generate SSH Keys on Ubuntu eller OpenSSH eller andre ressurser på Internett.
,#!/bin/bash
#Skriptet tar backup av min hjemmekatalog til en annen server med IP 192.168.1.3
# function rsynchome returnerer enten TRUE eller FALSE.
function rsynchome()
{
if
rsync -Scatx -e ssh ~/ brukernavn@192.168.1.3:~/backup
then
return
else
false
fi
}
#IF-testen nedenfor resulterer i melding: VELLYKKET, hvis function rsynchome returnerer TRUE
#IF-test nedenfor resulterer i melding MISLYKKET, hvis function rsynchome #returnerer FALSE
if rsynchome
then
echo
echo -e «=============\nVELLYKKET\n=============»
exit 0
else
echo
echo -e «=============\nMISLYKKET\n=============» >&2
echo
exit 1
fi
Functions, slik som rsynchome(), defineres med et funksjonsnavn vi finner på selv. Vi trenger ikke bruke paranteser slik det er gjort her, men det gjør heller ingen skade.
All logikk i funksjonen plasseres mellom to klammeparanteser: { }.
Funksjoner returnerer enten true eller false. Derfor kan man kalle på funksjonen senere i skriptet ved å skrive funksjonsnavnet og dermed teste om funksjonen ble utført vellykket eller ikke. I dette tilfellet vil vi teste om kjøring av backup til remote host brukernavn@192.168.1.3~/backup har vært vellykket.
Function rsynchome() benytter rsync til å kopiere alle endringer i vår hjemmekatalog(~/) til katalogen ~/backup som befinner seg på remote host brukernavn@192.168.1.3
I dette eksempelet bruker vi rsync med -e svitsj for å angi hvilket remote shell som skal benyttes, her ssh.
I tillegg bruker vi kolon : mellom adressen til remote host og destinasjonskatalog vi skal kopiere til for å fortelle rsync at vi kopierer over ssh . Slik:
brukernavn@192.168.1.3:~/backup
(Det er ingen mellomrom her)
Når vi kaller på rsynchome i en ny if-test returnerer if-testen én av to mulige meldinger:
- «Vellykket» når function rsynchome() er true(sann).
- «Mislykket» når function rsynchome() er false(usann).
\n gir ny linje i tekststrengen som angis mellom 2 anførselstegn. Vi bruker echo -e hvor -e betyr: «enable interpretation of the following backslash escapes». I dette tilfellet \n, som betyr New Line.
Kommandoen echo -e «=========\nVELLYKKET\n=========» tolkes derfor slik at dette blir 3 linjer:
=========
VELLYKKET
=========
Hvis rsynchome returnerer FALSE sender vi meldingen MISLYKKET til stderr med >&2. Da vises feilmeldingen på terminalen:
=========
MISLYKKET
=========
Vi trenger ikke å skrive return true hvis det lykkes. Det holder med return hvis if-testen er sann. Vi må imidlertid skrive false dersom if-testen er usann.
Hvis if-testen er sann, avslutter vi med exit 0.
Hvis if-testen er usann, avslutter vi med exit 1.
here document
«here document» eller «Here Document» er et nyttig verktøy man kan bruke i skript.
La oss si at vi har en remote server som vi ønsker regelmessig å dumpe en database på ved hjelp av skript vi kan kjøre på vår lokale server.
Dette eksempelet viser hvordan vi kan dumpe en database på en remote server ved å kjøre et skript med et «here document» på vår lokale server.
#!/bin/bash
#Skript for sql-dump på remote server
#public og private keys for ssh inn på remote server
#defaults file på remote server for innlogging til mysqldump og dump av sql
heredoc=»$(cat <<EOF
who
function dumpsql()
{
if
mysqldump –defaults-file=/home/brukernavn/.mysql/my.cnf –skip-opt –single-transaction\
–set-charset –create-options –quick –force –add-locks –extended-insert –add-drop-table\
–no-autocommit –routines –triggers -h 192.168.1.3 brukernavn\
> /home/brukernavn/sqldump/d_base.sql
then
return
else
false
fi
}
function visfil()
{
echo «===========================»
echo «DUMPET FIL i DIR ~/sqldump er:»
ls -las ~/sqldump
echo «===========================»
}
function melding()
{
if dumpsql;
then
echo
echo «===================»
echo «VELLYKKET SQLDUMP»
echo «===================»
echo
visfil
exit 0
else
echo -e «===================\nMISLYKKET SQLDUMP\n===================» >&2
exit 1
fi
}
melding
logname
EOF
)»
ssh -t brukernavn@192.168.1.3 «$heredoc»
exit 0
Poenget med «here documentet» her er følgende:
- Logge inn på remote server over ssh
- Kjøre here doc- koden der.
Dette gjør det mulig å kjøre et skript på en lokal server som utfører arbeidsoppgaver på en remote server ved hjelp av en variabel som inneholder all kode vi trenger. Dette hadde ikke vært mulig uten here doc.
Legg merke til nest siste kodelinje:
ssh -t brukernavn@192.168.1.3 «$heredoc»
Her sender vi altså en variabel kalt «$heredoc» til en remote server. Variabelen inneholder all kode som er skrevet i variabelen heredoc.
Denne koden blir da kjørt grunnet bruk av ssh -t, som forklares slik i man ssh:
-t‘ Force pseudo-tty allocation. This can be used to execute arbitrary screen-based programs on a remote machine, which can be very useful, e.g. when implementing menu services. Multiple -t options force tty allocation, even if ssh has no local tty.
Gevinsten ved dette er at vi kan administrere gjøremål på en remote server uten å måtte logge inn på den, men i stedet gjøre arbeidsoppgaver på en remote server ved å kjøre et skript på vår lokale server.
Med dette skriptet kan man dumpe en database på en annen server uten å besøke serveren. Vi trenger kun å skrive navnet på skriptet som vi kjører lokalt.
Lære mer?
Skripting er et enormt felt, og her har vi bare «scratched the surface».
Den som er interessert i å lære mer må finne andre ressurser og/eller prøve seg fram selv.