dd if=/dev/sda |gzip| dd of=archivo.tgz

udpcast

ncp

ssh

python

cloner googlecode

copia restaura mama-version

partimage-ng

cat

-----------------------

añadir udpcast y zsplit

http://www.device-image.de/main_docu.htm

http://wiki.houseofsysadmins.com/spip.php?article15

------------------------

Cloning

Useful tools

Usage examples

# Listener:
nc -v -l -p 30000 > hda1.img
# or
nc -v -l -p 30000 | dd of=/dev/hda1
# Source:
dd_rescue /dev/hda1 - | nc 192.168.1.2 30000 -w 3
# or
dd if=/dev/hda1 | nc 192.168.1.2 30000 -w 3

# clone disk via dd
dd if=/dev/hda of=/dev/hdc
Notice: adjust the options to improve performance, for example adjusting blocksize (bs=...) is strongly recommended.

tar cvzSf - directory/ | ssh foobar@target "dd of=/path/to/file.tgz"

export RSYNC_RSH=ssh; rsync -a /mystuff foobar@target_machine:~/

# clone disk via pcopy:
touch /tmp/diskimage.img
pcopy /dev/hda /tmp/diskimage.img

# This one uses CPU cycles on the remote server to compare the files:
ssh target_address cat remotefile | diff - localfile
cat localfile | ssh target_address diff - remotefile
# This one uses CPU cycles on the local server to compare the files:
ssh target_address cat <localfile "|" diff - remotefile

# push via ftp:
ftp> put "| tar cvf - ." myfile.tar
ftp> put "| tar cvf - . | gzip " myfile.tar.gz

# pull via ftp: 
ftp> get myfile.tar "| tar xvf -"

# Moving files around on local filesystem:
( cd SOURCEDIR && tar cf - . ) | (cd DESTDIR && tar xvpf - )

# ...
ssh target_address "( nc -l -p 9210 > remotefile & )" && cat source-file | gzip -1 - | nc target_address 9210

# backup specific directories via cpio and ssh:
for f in directory_list; do find $f >> backup.list done
cpio -v -o --format=newc < backup.list | ssh user@host "cat > backup_device"

# overwrite your first hard disk with null bytes:
dd if=/dev/zero of=/dev/hda

# securely erase files/partitions (please take a look at the
# manpage for some more information regarding security of deleting):
wipe -kq /dev/hda1

# clone using dump:
mke2fs -j /dev/target
mkdir -p /mnt/{source,target} &&
 mount /dev/target /mnt/target &&
 mount /dev/source /mnt/source
cd /mnt/target && dump -0f - /mnt/source | restore rf -

Useful tools

¿servidor pythoniano sirviendo archivos imágenes de partclone, por ejemplo? 

-------------------------------------------------

A la vez que bajas, grabas. "O de Oreja, no es un 0 de cero"

wget -qO - http://server/backup.img | ntfsclone -r -O /dev/sda1 -

-------------------------------------------------

UDF PARA DVDS

dvd+rw-format -force=full /dev/hdd

mkudffs --lvid="dvd-backup" --udfrev=0x0150 /dev/hdd

mkdir -p /mnt/disc mount -t udf -o rw,noatime /dev/hdd /mnt/disc

UDF PARA CDS

Ahora empezamos a realizar los pasos normales para cada CD­RW que deseemos tener como 
escritura de paquetes:
Todo como 'root'
   1.­ Primero formateamos el CD con “cdrwtool ­d <dispositivo> ­q
   2.­ Cargamos los módulos de escritura por paquetes 
     ● modprobe udf
     ● modprobe pktcdvd
        Deberemos de comprobar que se ha generado /dev/pktcdvd/control
   3.­ Creamos nuestra unidad virtual que nos permitir grabar por paquetes.
         pktsetup /dev/pktcdvd/cdwriter /dev/hda
         mount /dev/pktcdvd/cdwriter /media/Backup ­t udf ­o rw,noatime
  
   4.­ Después para desmontar la unidad realizaremos
      umount /media/Backup
      pktsetup ­d cdwriter
NOTA:
   En mi Ubuntu el proceso de crear la unidad virtual lo realizo más sencillo:
      1.  Tengo definido en el fichero “/etc/default/udftools” la unidad de CD como la unidad de 
           escritura de paquetes
      2.  Con ejecutar sudo /etc/init.d/udftools restart es suficiente, en realidad tampoco se realiza 
   pues se ejecuta al iniciarse.
3.  Solo nos queda montar la unidad de paquetes definida “/dev/pktcdvd/cdwriter” en el 
   directorio que nosotros queramos.
4.  Para desmontar realizamos lo mismo. 
 

-------------------------

RSYNC

rsync -vaz --progress --exclude '/mnt/hda3' / /mnt/hda3

Copia de seguridad de una partición entera a otra montada en /backup
rsync -ax --delete --force --exclude /backup / /backup/

DUMP/RESTORE

Solo para ext2 y ext3

Funciona a nivel de sistema de ficheros. Ignora bloques no usados.

Puede hacer copias incrementales!!!

http://www.linuxfocus.org/Castellano/March2005/article370.shtml

A linus no le gusta dump/restore: http://www.ussg.iu.edu/hypermail/linux/kernel/0104.3/0727.html

-------------------------------------------------------------------------

Compilar icewm con tema chachi

busca "metal" en ybutton.cc y ponlo igual que flat, o sea, simplemente con un d=0;

--------------------------------------------------------------------------

Otro Offtopic

apt-get install mono monodevelop libmono-winforms1.0-cil

bajar rasterbator

bajar parche en el directorio de source de rasterbator

parchear con $ patch -i Rasterbator.buildfix1.diff

debe salir esto:

patching file MainForm.cs
patching file Makefile

Luego compilamos:

make

da dos warnings pero el programa rula con "mono rasterbator.exe"

(programa y parche subidos a pbwiki)

------------------------------------------------------------

Offtopic:

4.2 - Captura prueba SoX ALSA Ensoniq

# sox -V -r 48000 -w -t alsa /dev/snd/pcmC0D0c -t .wav test.wav

Remoto wxp con seamless instalado

rdesktop -u remoto -p remoto -A -s "c:seamseam.exe notepad" 192.168.0.14

-------------------------------------------------------------

INFO TEMPORAL POR PROBAR

COMPARTIR UN ARCHIVO RÁPIDÍSIMAMENTE

EL QUE HARÁ DE SERVIDOR

$ nc -l -p 8080 -q 5 < archivo.html

EN EL CLIENTE

en el navegador pondrás http://192.168.1.123:8080

burning CD-Roms over the network

I found this very useful, to pull a backup from a host out of physical reach.

One way to remotely burn CDs is by using rscsi[1] from within cdrecord[2]

cdrecord dev=REMOTE:user@host:0,0,0 speed=0 .... theimage.iso

============

http://orgs.man.ac.uk/documentation/partimage/index-6.html

Truco para grabar en CD.

Elegir que corte a los 700Mb (o a los 200, por ej, si no tenemos más espacio) y luego seleccionar "esperar"

Esperar después de cada volumen es útil si no tenemos espacio en disco para toda la copia y decidimos grabar en CD (o guardar en un disco flash) tras comprimir cada trozo, borrar, y luego seguir creando la imagen del siguiente trozo.

Esto no vale, pero graba a lo bestia bit a bit en un CD incluso si se pone la opción multi sigue grabando sesiones a lo bestia. Luego hay que recuperarlas con dd y mirar donde empieza y termina cada sesión con la opción -toc.  Si en vez de un archivo, se ponde un dispositivo de bloques...

cdrecord -v   -eject   dev=2,0,0   speed=24 archivo

cdrecord -v   -eject   dev=/dev/hdc   archivo 

Grabar al vuelo 

mkisofs archivo | cdrecord -v dev=2,0,0 -

mkisofs archivo | cdrecord -v dev=/dev/hdc -

al vuelo en multisesión

mkisofs archivo | cdrecord -multi -v dev=2,0,0 -    [para la primera grabación]

mkisofs -C `cdrecord dev=2,0,0 -msinfo` -M /dev/sr0 archivo2 | cdrecord -multi -v dev=2,0,0 -  [para la siguiente]

Para soporte de nombres largos y compatibilidad linux-windows añadir a las opciones de mkisofs -JIR

Truco 2.

Con un CDRW ...udf...

Truco 3.

En un DVD (comprobar, no me acuerdo bien si era así)

growisofs -Z /dev/sr0 archivo

growisofs -M /dev/sr0 archivo2

Truco 4.

Disco RAM.

-----------------------------------------------------------------------------

fdisk -l

MBR=CARGADOR+TABLAPARTI

Grabar el SECTOR DE ARRANQUE MBR

dd if=/dev/hda of=sector-de-arranque count=1 (como por defecto son 512bytes los que graba...o sea, el primer sector)

dd if=sector-de-arranque of=/dev/hda count=1

Grabar solo el cargador de arranque del MBR

dd if=/dev/hda of=mbr bs=446 count=1

Grabar sólo TABLA DE PARTICIONES

 dd if=/dev/hda skip=446 of=tabla-dd bs=1 count=64

para volcarla luego habrá que usar seek en lugar de skip.

OTRA FORMA

dd if=/dev/hda of=mbr-entero bs=512 count=1

dd if=mbr-entero of=/dev/hda bs=1 count=64 skip=446 seek=446

 dd if=mbr-entero of=tablita bs=1 count=64 skip=446

skip es para que se lo salte del if

y seek para que se lo salte también en el of

----- 

dd if=/dev/hda of=/dev/sda conv=notrunc,noerror,sync bs=4k

Si queremos saber cuánto tiempo ha tardado el comando podemos preceder el comando "time" al comando anterior:

# time dd if=/dev/hda1 | bzip2 --best > partition.bz2

Y nos mostrará el tiempo tardado.

Y si hdchico es más pequeño que hdgrande, para que se salte la tabla de particiones???:

dd if=/dev/hdgrande skip=1 of=/dev/hdchico seek=1 bs=4k conv=noerror

--------------------------------------------------------------------------------------------- 

TAMBIÉN POR RED

dd if=/dev/hda | SSH usuario@equipo_remoto "gzip -9 > imagen-de-hda.gz"

ssh usuario@equipo_remoto "cat 20040928-notebook-hda.gz | gunzip" | dd of=/dev/hda

Si se necesita respaldar cada partición, entonces es necesario guardar los datos correspondientes al MBR (master boot record) y eso lo hice con esta línea:

dd if=/dev/hda bs=512 count=1 | SSH usuario@equipo_remoto "cat - > 20040928-notebook-hda-mbr.dd"

está claro que no es necesario hacer una compactación de esto, ya que es un archivito muy chico. Y cada partición es la respaldé con la siguiente linea (ejemplo de hda3):

dd if=/dev/hda3 | SSH usuario@equipo_remoto "gzip -9 > 20040928-notebook-hda3.gz"

Para proceder a recuperar se debe primero levantar nuevamente el MBR y la tabla de partición:

SSH usuario@equipo_remoto "cat 20040928-notebook-hda-mbr.dd" | dd of=/dev/hda

y es necesario rebootear, para que todo el sistema lea la nueva tabla de partición del disco; obviamente se sigue siempre arrancando desde el CD con Knoppix, y entonces si se puede proceder a recuperar cada una de las particiones, con este ejemplo:

SSH usuario@equipo_remoto "cat 20040928-notebook-hda3.gz | gunzip" | dd of=/dev/hda3

----------------------------------------------------------

dvd-ram

dvdrw formateado con udf: cdrwtool -d /dev/cdrom -q

Hasta 576 Mb

hacer un disco ram y trocear el partimage al tamaño del disco ram, ir grabando a un CD.

Mondoarchive-mondorestore :-) hace falta un sistema instalado y carga desde él.

------------------------------------------------------------------------------------------------------------------------------------------------------- 

TÍTULO: Cómo hacer copias de seguridad de particiones o discos duros enteros.

OBJETIVO: El objetivo principal es presentar el uso de una de las herramientas más útiles para

hacer copias de seguridad íntegras de particiones que existen en el mundo libre, esta es, Partimage.

La charla consistirá primeramente en explicar brevemente cómo es un disco duro y cómo se sitúan en él

las distintas particiones.

Luego realizaremos una copia y restauración de una partición para mostrar un poco la sencilla

interfaz de partimage.

En tercer lugar, explicaremos cómo se pueden hacer copias de seguridad de discos duros enteros conteniendo

todas sus particiones.

En cuarto lugar, comentaremos cómo se pueden hacer las copias anteriores por red.

Y en quinto lugar, formularemos una propuesta para poder automatizar todo el proceso con un sencillo

script y un liveCD, tanto de la creación de las copias como de la restauración.

DURACIÓN: más o menos 40 min

MATERIALES: en principio con el proyector sería suficiente para usar alguna presentación multimedia y para

conectar los ordenadores a modo de pantalla. El ordenador portátil me lo llevaría yo.

------------------------------------------------------------------------------------------------------------------------------------------------------------------

otras alternativas:

mondo copias en CDRW

multiCD

cpio

dump restore

ver: http://www.rediris.es/cert/doc/unixsec/node13.html

b) Hacemos una copia de la tabla de particiones en un archivo:

          sfdisk -d /dev/hda > tabla_de_particiones

c) Hacemos una copia del sector de arranque del disco duro (MBR):

          dd if=/dev/hda of=sector_de_arranque count=1   (como por defecto graba 512 bytes no hace falta poner bs=512...)

Nota: en realidad b) está incluido en c) y en cuanto a c) ya tenemos la opción en partimage para recuperarlo, pero siempre es bueno tener una copia de la tabla de particiones y el MBR porque hay muchos virus que machacan el sector de arranque (incluso creo que hay sistemas operativos que tienen un comportamiento similar ;). Además, hay BIOS mal programadas que influyen en que no se grabe bien el sector de arranque y es necesario forzar la escritura o hacerla varias veces.

Y para el rescate de todo tendremos que invertir el proceso:

1) Restauramos el sector de arranque:

          dd if=sector_de_arranque of=/dev/hda

2) Restauramos la tabla de particiones:

          sfdisk -d /dev/hda < tabla_de_particiones

          Y si se resiste, prueba esto: sfdisk --force /dev/hda < tabla_de_particiones

3) Restauramos una tras otra las particiones del disco duro con partimage.

                partimage ...

para la demostración ... con un live se abren dos consolas

preparativos:

dhclient

apt-get install partimage partimage-server

killall partimaged

mcedit /etc/partimaged/partimagedusers

introducir partimag y guardar

luego passwd partimag y se le pone una contraseña, ej mola

luego preparar el directorio destino

Lo más fácil es irse a /mnt/

mkdir hda6

mount -t auto /dev/hda6 hda6

chown partimag hda6

cd hda6

partimaged -d .

tiene que tener permisos de escritura chmod 777

ó

chown -R partimag.partimage /directorio

se abre el servidor en cd /directorio y se escribe partimaged -d . (para indicar que es en ese directorio donde queremos guardar la imagen)

luego se abre partimage en el otro lao y se mete el IP del servidor, partimag y mola y luego palante...

La compresión que se usa en los liveCDs

squashfs

cloop

...

También se podría usar con dd?? entubar?? y luego montar y remontar???

 http://parchive.sourceforge.net/

http://www.sanitarium.net/unix_stuff/par2calc.txt

DIRECTO A DVD+RW con formato udf

dvd+rw-format /dev/sr0

mkudffs --media-type=dvd /dev/sr0

(en kernel 2.6.20 solucionado lo de la limitación de 1Gb)

DIRECTO A CD con formato udf

cdrwtool -d /dev/sr0 -q

modprobe udf

modprobe pktcdvd

MAKEDEV pktcdvd

pktsetup pktcdvd0 /dev/sr0

-------------------------------------------

But udf is already in 2.10. I don't use packetwriting.

Following are the commands I use:

and I can read and write to the hdd udf device (in my case a DVD-RW).

Indeed the device is somewhat slow.

But it gives me opportunities now for extra space, as my system is pretty full on HDD space.

I still have to find out how to prepare a blank DVD for read/write

-------------------------------------------------------

OK left a few things out.

You need to do this once

before said three li

---------------------------------------------------

Here's how to boot a LiveCD from HD (using grub, Knoppix [or knoppix based LiveCD iso] and a Linux system):

-create a mountpoint to mount the ISO with loopback:

mkdir /mnt/LiveISO

-mount the image:

mount -t iso9660 -o loop,ro /DOWNLOADS/Knoppix-3.7-en.iso /mnt/LiveISO

-create a directory on the device where you are going to boot from:

mkdir /mnt/hda4/KNOPPIX

-copy the contents of the mounted image to that directory:

cp /mnt/LiveISO/KNOPPIX/* /mnt/hda4/KNOPPIX/

-copy kernel and initrd files to yor boot device:

cp /mnt/LiveISO/boot/* /boot/

-edit the menu.list located in /boot/grub and add an entry like this to it:

title  KNOPPIX

root  (hd0,0)

kernel  /linux26 ramdisk_size=100000 fromhd=/dev/hda4

initrd  /minirt26.gz

savedefault

boot

________________________________

Links de obligada visita:

http://www.linux-backup.net/App/

--------------------------------------------------- 

Formatting and using dd to write a bootable ISO image to DVD-RAM (in this case the device in on /dev/scd0)

• This seems to be optional - but good information to know about) mkudffs - Format a device, creating an empty UDF filesystem
• mkudffs --media-type=dvdram /dev/scd0
• (Or if CD-RW): mkudffs --media-type=cdrw /dev/scd0
• Rather than the above: try mke2fs -b 2048 /dev/scd0 to create a blank filesystem or wipe the previous disk.

   

• Then to write the ISO image (in this case created by mondorescue), do
• dd if=/tmp/isos/1.iso of=/dev/scd0

  (make sure you are writing to a valid device or you will fill up your /dev area pretty quickly)

Copias con CAT también funciona como dd

cat /dev/hda3 > copia

AFIO CPIO TAR DUMP RESTORE...FLEXBACKUP

Create a linux only ext2 cdrom!

Create a ext2 file system in a file and mount it
   dd if=/dev/zero of=cd.ext2 bs=1024k count=650
   /sbin/mke2fs  -b 2048  cd.ext2
   mount -t ext2 -o loop=/dev/loop1 cd.ext2 /mnt

Note mke2fs may complain that the device is not a block special.
Just tell it to proceed anyway.

Copy the files into the file system and when finished unmount it.
Now just burn "cd.ext2" directly to the cdrom using cdrecord as if
it was an ISO image.

NOTE: if you mount this filesystem via the "fstab" file ensure the last two
numbers are 0 (zeros) so the fsck does NOT check the filesystem (it will
fail).

=====================================================================

udpcast udp-sender udp-receiver

If you would like to broadcast an image to multiple machines, I suggest using udp-receiver / udp-sender for an example, making images for Windows machine:
On source, once, to create your image;
Code:

# I reduce the size to the minimum
ntfsresize -s 10G -f /dev/sda1
# Make a compressed image using lzo (you can use a better compression but this one is very speed efficient for piping in udp-sender directly)
ntfsclone -O - -s -f /dev/sda1 | lzop > image.ntfs.lzo

On the machines I would run, in an automatic script:
(CAUTION; Wipes everything on the machine you use it)
Code:

# Creates a partition filling the disk
echo ",,07" | sfdisk /dev/sda
# Active the first partition
sfdisk -A1 /dev/sda
# Creates a Win2k/XP MBR
ms-sys -m /dev/sda
# Receives the server's image in a buffer, decompresses it and write content to partition 1
udp-receiver | mbuffer -m 20M | lzop -d | ntfsclone -r -O /dev/sda1 -
# Resizes the partition to fill the disk and answers 'yes' to the warning automatically
yes | ntfsresize -f /dev/sda1
# Reboots in Windows!
reboot

Then finally on the server, after booting all the machines:
Code:

udp-sender < image.ntfs.lzo

This will send the image to all the computer, in multicast, so it is bandwidth efficient as if the switch supports it, only the ports in the multicast group will receive the data, the data will be sent on the link once, and best of all, data is sent compressed on the link! Once the command is typed, udp-sender will ask to press any key to start the sending.

I used a Windows machine as an example because those machine crash so often we have to ghost them in batches :roll: however, it can be applied to any partition type, and if you need to copy the partition table and boot loader code,
Code:

dd if=/dev/sda of=mbr.bin bs=512 count=1

certainly does the trick too, but I guess what you will want in this is udp-receiver and udp-sender!

===================================================================================

=============

Desde el server tiramos la imagen:

# gunzip -c sector_booteo | udp-sender

En el caso anterior, udp-sender por defecto manda el archivo en multicast, en el caso de que sea una sola pc la que va a ser clonada es conveniente hacerlo en point to point

# gunzip -c sector_booteo | udp-sender --pointopoint

Otra opción es hacerlo en broadcast, usar sólo en caso de que las anteriores no funcionen, ya que satura la red al máximo.

# gunzip -c sector_booteo| udp-sender --broadcast

Y desde el cliente recibimos la imagen de la siguiente manera:

# udp-receiver --nokbd | partimage -b restore /dev/sda1 stdin

Una vez terminado hacemos lo mismo con la segunda parte:

Server:
# gunzip -c imagen_disco | udp-sender

Cliente:
# udp-receiver --nokbd | partimage -b restore /dev/sda2 stdin

Reiniciamos y listo! :)

============================================================================0

==================================================================0000

1- Prepara los clientes

udp-receiver |dd of=archivo

2- Manda el archivo por el servidor

dd if=archivo | udp-sender