rsync - od bráchy

rsync -av --stats --progress -e ssh /co/chci/zkopnout user@server:/kam/s/tim

Synchronizace

např. chci zjistit rozdíly ve dvou adresářích http://rsync.samba.org/examples.html

 rsync -av  adresar1 adresar2 --dry-run

Stáhnout adresář z FTP serveru

vytvořitdefiniční soubor a do něj vložit

open ftp://user:pass@195.178.91.251
mirror -c /martyn /home/martyn/work/mirror
exit

a pak spustit

 lftp -f soubor.txt

Komprimace a nahrátí na server

echo "upload na aaaweb"
cd /home/framework &> /dev/null
sudo tar cpzf archive.tgz /home/framework/www
ncftpput -E -u framework -p heslo aaaweb.eu / /home/framework/archive.tgz &> /dev/null
#sudo rm "/home/framework/upload.tgz"

Synchonizace profilu na jednotlivych pocitacich

• viz. soubor "synchronizace_profile.sh"
• skript ulozime do adresare ~/bin
• zalozime adresar ~/skel a v nem symbolicke odkazy na soubory, ktere chci kopirovat do vzdalenych systemu
• pozor : adresar .ssh nedelat z nej symbolicky odkaz!!! ale plnohodnotne jej prekopirovat
• vyuzit i sluzby ssh
• agent
• priznak "
• h" u "tar" znamena ze ze symbolickych odkazu udela normalni soubory

Definiční soubor pro synchronizaci

###  tohle zrcadlit nebudu ###
- logs/

### cely korenovy adresar dokumentu ###
+ /usr/
+ /usr/local/
+ /usr/local/apache/
+ /usr/local/apache/*

### uzivatelske adresare ###
+ /home/*/www/
+ /home/*/www/**

### obrazky, archivy... ###
+ *.jpg
+ *.pdf

### vse ostatni odstranime ###
- *

Synchronizace profile

  #!/bin/sh

 if [ -z "$1" ]; then
   echo "Pis: `basename $0` hostitel"
   exit
 fi

 cd ~/.skel
 tar zhcf - . | ssh $1 "tar zpvxf -"

Synchronizace části systému

#!/bin/bash

#
# balance-push - Push content from the master server (localhost) 
# to multiple front- and back-end servers, in parallel.
#

# $FRONT_END lists the servers that receive the front-end (e.g. static content) updates.
#
FRONT_END=$(cat /usr/local/etc/servers.front)

# $BACK_END lists the hosts that receive the full back-end (e.g. everything) updates.
#
BACK_END=$(cat /usr/local/etc/servers.back)

# $TARGET specifies the filesystem root on the remote host to push to.
# Normally, you want this to be /, unless you're doing testing.
#
TARGET=/

# $EXCLUDE specifies the prefix of the per-mode rsync exclude files.
# For example, if your exclude files are /usr/local/etc/balance.front and
# /usr/local/etc/balance.back, set this to "/usr/local/etc/balance". The 
# per-mode extensions will be added.
#
EXCLUDE=/usr/local/etc/balance

# $LOCK_DIR specifies a path to put the lock files in.
#
LOCK_DIR=/var/tmp

######## Ignore the shell functions behind the curtain. ########

PATH=/bin:/usr/bin:/usr/local/bin

lock (  ) {
local lockfile="$LOCK_DIR/balance.$1.lock"
if [ -f $lockfile ]; then
if kill -0 $(cat $lockfile); then
echo "$0 appears to be already running on $1."
echo "Please check $lockfile if you think this is in error."
exit 1
else
echo "$0 appears to have completed for $1 without cleaning up its lockfile."
fi
fi
echo $$ > $lockfile
}

unlock (  ) {
rm -f $LOCK_DIR/balance.$1.lock
}

push_files (  ) {
local mode=$1 host=$2

if [ ! "$mode" -o ! -r "$EXCLUDE.$mode" ]; then
echo "$0 $$: mode unset for $host!"
return
fi

if [ ! "$host" ]; then
echo "$0 $$: host unset for push $mode!"
return
fi

lock $host

rsync --archive --rsh=ssh --delete --ignore-errors --whole-file 
--exclude-from="$EXCLUDE.$mode" / ${host}:${TARGET}

unlock $host
}

push_tier (  ) {
local mode=$1 host_list=$2

for host in $host_list; do
$SHELL -c "push_files $mode $host" &
done
}

export -f lock unlock push_files
export TARGET EXCLUDE LOCK_DIR PATH

[ "$FRONT_END" ] && push_tier front "$FRONT_END"
[ "$BACK_END" ] && push_tier back "$BACK_END"

#
# Fin.
#

Synchronizace casti souboroveho systemu s nastrojem rsync

• trik 41 (Server Li20nux)

#!/bin/bash
# zajisti spusteni synchronizace pomoci rsync a a zajisti, ze se jednotlive behy na zadnem serveru nebudou "predbihat"


# sem budu kopirovat aktualizace statickeho obsahu
FRONT_END=$(cat /usr/local/etc/servers.font)

# do techto serveru se budou kopirovat uplne aktualizace (tedy vse)
BACK_END=$(cat /usr/local/etc/servers.back)

# definuje koren souboroveho systemu na vzdalenem hostigeli, kam budeme kopirovat
TARGET=/

#
EXCLUDE=/usr/local/etc/zalohovani_01a.txt

# definuje cestu pro ukladani zamcenych souboru
LOCK_DIR=/var/tmp

PATH=/bin:/usr/bin:/usr/local/bin

lock () {
   local lockfile="$LOCK_DIR/balance.$1.lock"
   if [-f $lockfile]; then
      echo "$0 iz zrejme na $1 bezi, pokud ne zkontrolujte lockfile"
      exit 1
   else
      echo "$0 pro $1 se jiz zrejme dokoncil, ale nevymazal soubor zamku"
   fi
   fi
   echo $$ > $lockfile

}

unlock () {
   rm -f $LOCK_DIR/balance.$1.lock

}

push_files () {
   local mode=$1 host=$2

   if [! "$mode" -o ! -r "$EXCLUDE.$mode"] ; then
      echo "$0 $$: rezim pro $host neni nastaven!"
      return
   fi
   
   lock $host

   rsync --archive --rsh=ssh --delete --ignore-errors --whole-file --exclude-from="$EXCLUDE.$mode" / ${host}:${TARGET}
   unlock $host

   
}

push_tier () {
   local mode=$1 host_list=$2

   for host in $host_list; do
      $SHELL -c "push_files $mode $host" &
   done

}

export -f lock unlock push_files
export TARGET EXCLUDE LOCK_DIR PATH

["$FRONT_END"] && push_tier front "$FRONT_END"
["$BACK_END"] && push_tier back "$BACK_END"

Synchronizace pomoci Rsync

• vytvorit crony na kazdem z webovych serveru
• mit povolene rychle prihlaseni pres SSH (bez nutnosti zadavat heslo)
• bohuzel aktualizace musi probehnout asynchronne
• napr. kazdych pet minut, bude cilova kopie 5 min. stara
• pozor!!! pred dalsim spustenim z cronu je nutne zjistit zda predchozi synchronizace probehla cela, jinak dojde k "vyvrtkovemu efektu" kdy spustenim kazde nove synchronizace dojde k pretizeni serveru (ne
• li jeho zhrouceni)
• vhodne pro kopirovani celych systemu (napr. prvni), ale pokud se zmeni jen malo, tak zbytecne zatezuje sit

      % rsync -ae ssh server.monstav.com:/home/martyn /home/martyn

Prirustkove zalohovani

#!/bin/bash
# ----------------------------------------------------------------------
# mikes handy rotating-filesystem-snapshot utility
# ----------------------------------------------------------------------
# RCS info: $Id: ch03.xml,v 1.4 2003/02/21 23:15:12 chodacki Exp $
# ----------------------------------------------------------------------
# this needs to be a lot more general, but the basic idea is it makes
# rotating backup-snapshots of /home whenever called
# ----------------------------------------------------------------------

# ------------- system commands used by this script --------------------
ID=/usr/bin/id;
ECHO=/bin/echo;

MOUNT=/bin/mount;
RM=/bin/rm;
MV=/bin/mv;
CP=/bin/cp;
TOUCH=/bin/touch;

RSYNC=/usr/bin/rsync;


# ------------- file locations -----------------------------------------

MOUNT_DEVICE=/dev/hdb1;
SNAPSHOT_Rw=/root/snapshot;
EXCLUDES=/usr/local/etc/backup_exclude;


# ------------- the script itself --------------------------------------

# make sure we're running as root
if (( `$ID -u` != 0 )); then { $ECHO "Sorry, must be root. Exiting..."; exit; } fi

# attempt to remount the Rw mount point as Rw; else abort
$MOUNT -o remount,rw $MOUNT_DEVICE $SNAPSHOT_Rw ;
if (( $? )); then
{
$ECHO "snapshot: could not remount $SNAPSHOT_Rw readwrite";
exit;
}
fi;


# rotating snapshots of /home (fixme: this should be more general)

# step 1: delete the oldest snapshot, if it exists:
if [ -d $SNAPSHOT_Rw/home/hourly.3 ] ; then 
$RM -rf $SNAPSHOT_Rw/home/hourly.3 ; 
fi ;

# step 2: shift the middle snapshots(s) back by one, if they exist
if [ -d $SNAPSHOT_Rw/home/hourly.2 ] ; then 
$MV $SNAPSHOT_Rw/home/hourly.2 $SNAPSHOT_Rw/home/hourly.3 ; 
fi;
if [ -d $SNAPSHOT_Rw/home/hourly.1 ] ; then 
$MV $SNAPSHOT_Rw/home/hourly.1 $SNAPSHOT_Rw/home/hourly.2 ; 
fi;

# step 3: make a hard-link-only (except for dirs) copy of the latest snapshot,
# if that exists
if [ -d $SNAPSHOT_Rw/home/hourly.0 ] ; then 
$CP -al $SNAPSHOT_Rw/home/hourly.0 $SNAPSHOT_Rw/home/hourly.1 ; 
fi;

# step 4: rsync from the system into the latest snapshot (notice that
# rsync behaves like cp --remove-destination by default, so the destination
# is unlinked first. If it were not so, this would copy over the other
# snapshot(s) too!
$RSYNC 
-va --delete --delete-excluded 
--exclude-from="$EXCLUDES" 
/home/ $SNAPSHOT_Rw/home/hourly.0 ;

# step 5: update the mtime of hourly.0 to reflect the snapshot time
$TOUCH $SNAPSHOT_Rw/home/hourly.0 ;

# and thats it for home.

# now remount the Rw snapshot mountpoint as readonly

$MOUNT -o remount,ro $MOUNT_DEVICE $SNAPSHOT_Rw ;
if (( $? )); then
{
$ECHO "snapshot: could not remount $SNAPSHOT_Rw readonly";
exit;
} fi;

Spustí synchronizaci pomocí rsync a zajistí, aby se nepředbíhaly

#!/bin/bash
# zajisti spusteni synchronizace pomoci rsync a a zajisti, ze se jednotlive behy na zadnem serveru nebudou "predbihat"


# sem budu kopirovat aktualizace statickeho obsahu
FRONT_END=$(cat /usr/local/etc/servers.font)

# do techto serveru se budou kopirovat uplne aktualizace (tedy vse)
BACK_END=$(cat /usr/local/etc/servers.back)

# definuje koren souboroveho systemu na vzdalenem hostigeli, kam budeme kopirovat
TARGET=/

#
EXCLUDE=/usr/local/etc/zalohovani_01a.txt

# definuje cestu pro ukladani zamcenych souboru
LOCK_DIR=/var/tmp

PATH=/bin:/usr/bin:/usr/local/bin

lock () {
   local lockfile="$LOCK_DIR/balance.$1.lock"
   if [-f $lockfile]; then
      echo "$0 iz zrejme na $1 bezi, pokud ne zkontrolujte lockfile"
      exit 1
   else
      echo "$0 pro $1 se jiz zrejme dokoncil, ale nevymazal soubor zamku"
   fi
   fi
   echo $$ > $lockfile

}

unlock () {
   rm -f $LOCK_DIR/balance.$1.lock

}

push_files () {
   local mode=$1 host=$2

   if [! "$mode" -o ! -r "$EXCLUDE.$mode"] ; then
      echo "$0 $$: rezim pro $host neni nastaven!"
      return
   fi
   
   lock $host

   rsync --archive --rsh=ssh --delete --ignore-errors --whole-file --exclude-from="$EXCLUDE.$mode" / ${host}:${TARGET}
   unlock $host

   
}

push_tier () {
   local mode=$1 host_list=$2

   for host in $host_list; do
      $SHELL -c "push_files $mode $host" &
   done

}

export -f lock unlock push_files
export TARGET EXCLUDE LOCK_DIR PATH

["$FRONT_END"] && push_tier front "$FRONT_END"
["$BACK_END"] && push_tier back "$BACK_END"