Índice
São descritas ferramentas e dicas para gerir dados binários e de texto no sistema Debian.
![]() |
Atenção |
---|---|
O acesso de escrita descoordenado a dispositivos acedidos activamente e a ficheiros a partir de múltiplos processos não deve ser feito para evitar a condição de competição. Devem ser usados mecanismos de bloqueio de ficheiro que usem o flock(1) para o evitar. |
A segurança dos dados e a sua partilha controlada têm vários aspectos.
A criação de um arquivo de dados
O acesso a armazenamento remoto
A duplicação
O acompanhar do histórico de modificação
A facilitação da partilha de dados
A prevenção de acessos não autorizados a ficheiros
A detecção de modificação não autorizada de ficheiros
Estas podem ser realizadas usando a combinação de algumas ferramentas
Ferramentas de arquivo e compressão
Ferramentas de cópia de sincronização
Sistemas de ficheiros de rede
Media de armazenamento amovível
A shell segura
O sistema de autenticação
Ferramentas de sistema de controle de versão
Ferramentas de hash e encriptação criptográfica
Aqui está um sumário das ferramentas de arquivo e compressão disponíveis no sistema Debian.
Tabela 10.1. Lista de ferramentas de arquivo e compressão
pacote | popcon | tamanho | comando | extensão | comentário |
---|---|---|---|---|---|
tar
*
|
V:58, I:99 | 2459 | tar(1) |
.tar
|
o arquivador standard (de facto standard) |
cpio
*
|
V:33, I:99 | 920 | cpio(1) |
.cpio
|
arquivador estilo Unix System V, usar com o find(1) |
binutils *
|
V:60, I:73 | 14820 | ar(1) |
.ar
|
arquivador para a criação de bibliotecas estáticas |
fastjar *
|
V:1.9, I:17 | 216 | fastjar(1) |
.jar
|
arquivador para Java (estilo zip) |
pax
*
|
V:2, I:8 | 121 | pax(1) |
.pax
|
novo arquivador standard do POSIX, um compromisso entre
tar e cpio
|
afio
*
|
V:0.2, I:1.2 | 240 | afio(1) |
.afio
|
cpio extenso com compressão por ficheiro etc.
|
gzip
*
|
V:90, I:99 | 215 | gzip(1), zcat(1), … |
.gz
|
LZ77 utilitário de compressão do GNU (o standard de facto) |
bzip2
*
|
V:55, I:80 | 132 | bzip2(1), bzcat(1), … |
.bz2
|
Compressão de organização de
blocos de Burrows-Wheeler utilitário com um rácio de compressão mais
alto que o
gzip(1)
(mais lento que o gzip com sintaxe semelhante)
|
lzma
*
|
V:3, I:47 | 172 | lzma(1) |
.lzma
|
LZMA utilitário de compressão com rácio de compressão mais alto que o gzip(1) (descontinuado) |
xz-utils *
|
V:13, I:67 | 383 | xz(1), xzdec(1), … |
.xz
|
XZ utilitário de compressão com rácio de
compressão mais alto que o
bzip2(1)
(mais lento que o gzip mas mais rápido que o
bzip2 ; substituto para o utilitário de compressão LZMA)
|
p7zip
*
|
V:1.3, I:12 | 1116 | 7zr(1), p7zip(1) |
.7z
|
7-Zip arquivador de ficheiros com alta taxa de compressão (compressão LZMA) |
p7zip-full *
|
V:25, I:41 | 4068 | 7z(1), 7za(1) |
.7z
|
7-Zip arquivador de ficheiros com rácio de compressão alto (LZMA compressão e outros) |
lzop
*
|
V:0.5, I:4 | 112 | lzop(1) |
.lzo
|
LZO utilitário de compressão com mais alta
compressão e mais rápida descompressão que o
gzip(1)
(rácio de compressão mais baixo que o gzip com sintaxe
semelhante)
|
zip
*
|
V:6, I:41 | 636 | zip(1) |
.zip
|
InfoZIP: ferramenta de compressão e arquivo do DOS |
unzip
*
|
V:28, I:70 | 408 | unzip(1) |
.zip
|
InfoZIP: ferramenta de descompressão e de desarquivar do DOS |
![]() |
Atenção |
---|---|
Não defina a variável " |
![]() |
Nota |
---|---|
O arquivo
tar(1)
gzipado usa a extensão de ficheiro " |
![]() |
Nota |
---|---|
O arquivo
tar(1)
comprimido em xz usa a extensão de ficheiro " |
![]() |
Nota |
---|---|
Método de compressão popular em ferramentas FOSS
tal como o
tar(1)
têm se movido como se segue: |
![]() |
Nota |
---|---|
cp(1), scp(1) e tar(1) podem ter algumas limitações para ficheiros especiais. cpio(1) e afio(1) são mais versáteis. |
![]() |
Nota |
---|---|
O cpio(1) e o afio(1) são desenhados para serem usados com o find(1) e outros comandos e são apropriados para criar scripts de backup pois a parte de selecção de ficheiros do script pode ser testada independentemente. |
![]() |
Nota |
---|---|
O
afio(1)
comprime cada ficheiro num arquivo. Isto faz com que o
|
![]() |
Nota |
---|---|
A estrutura interna dos ficheiros de dados do OpenOffice são ficheiros
" |
Aqui está um sumário de ferramentas de cópia simples e salvaguarda disponíveis no sistema Debian.
Tabela 10.2. Lista de ferramentas de cópia e sincronização
pacote | popcon | tamanho | ferramenta | função |
---|---|---|---|---|
coreutils *
|
V:90, I:99 | 13477 | GNU cp | copia localmente ficheiros e directórios ("-a" para ser recursivo) |
openssh-client *
|
V:55, I:99 | 2302 | scp |
copia remotamente ficheiros e directórios (cliente, "-r "
para ser recursivo)
|
openssh-server *
|
V:67, I:81 | 790 | sshd | copia ficheiros e directórios remotamente (servidor remoto) |
rsync
*
|
V:19, I:59 | 724 | - | sincronização remota a salvaguarda de 1 via |
unison *
|
V:0.8, I:2 | 1772 | - | sincronização remota a salvaguarda de 2 vias |
Copiar ficheiros com o rsync(8) oferece funcionalidades mais ricas que os outros.
algoritmo de transferência delta que envia apenas as diferenças entre os ficheiros da fonte e os ficheiros existentes no destino
algoritmo de verificação rápida (predefinido) que procura ficheiros que alteraram no tamanho ou ha hora da última modificação
opções "--exclude
" e "--exclude-from
"
semelhantes ao
tar(1)
sintaxe de "uma barra final no directório fonte" que evita a criação de um nível de directório adicional no destino.
![]() |
Dica |
---|---|
A execução do script |
![]() |
Dica |
---|---|
Ferramentas de sistema de controlo de versão (VCS) em Tabela 10.16, “lista de ferramentas de sistemas de controle de versão” podem funcionar como a copia de multi-modos e ferramentas de sincronização. |
Aqui estão várias maneiras de arquivar e "desarquivar" o conteúdo completo
do directório "./source
" usando diferentes ferramentas.
GNU tar(1):
$ tar cvzf archive.tar.gz ./source $ tar xvzf archive.tar.gz
cpio(1):
$ find ./source -xdev -print0 | cpio -ov --null > archive.cpio; gzip archive.cpio $ zcat archive.cpio.gz | cpio -i
afio(1):
$ find ./source -xdev -print0 | afio -ovZ0 archive.afio $ afio -ivZ archive.afio
Aqui estão algumas maneiras de copiar o conteúdo inteiro do directório
"./source
" usando diferentes ferramentas.
Cópia local: directório "./source
" → directório
"/dest
"
Cópia remota: directório "./source
" em máquina local →
directório "/dest
" na máquina
"utilizador@máquina.domínio
"
rsync(8):
# cd ./source; rsync -av . /dest # cd ./source; rsync -av . utilizador@máquina.domínio:/dest
Você pode alternativamente usar a sintaxe de "uma barra à direita no directório fonte".
# rsync -av ./source/ /dest # rsync -av ./source/ utilizador@máquina.domínio:/dest
cp(1) de GNU e scp(1) de openSSH:
# cd ./source; cp -a . /dest # cd ./source; scp -pr . utilizador@máquina.domínio:/dest
GNU tar(1):
# (cd ./source && tar cf - . ) | (cd /dest && tar xvfp - ) # (cd ./source && tar cf - . ) | ssh utilizador@máquina.domínio '(cd /dest && tar xvfp - )'
cpio(1):
# cd ./source; find . -print0 | cpio -pvdm --null --sparse /dest
afio(1):
# cd ./source; find . -print0 | afio -pv0a /dest
Você pode substituir ".
" por "foo
"
para todos os exemplos que contêm ".
" para copiar
ficheiros do directório "./source/foo
" para o directório
"/dest/foo
".
Você pode substituir ".
" pelo caminho absoluto
"/caminho/para/fonte/foo
" para todos os exemplos que
contém ".
" para abandonar "cd
./source;
". Estes copiam ficheiros para localizações diferentes
dependendo das ferramentas usadas como se segue.
"/dest/foo
":
rsync(8),
cp(1)
do GNU, e
scp(1)
"/dest/path/to/source/foo
":
tar(1)
do GNU,
cpio(1),
e
afio(1)
![]() |
Dica |
---|---|
rsync(8)
e
cp(1)
do GNU têm a opção " |
O find(1) é usado para seleccionar ficheiros para o arquivo e copiar comandos (veja Secção 10.1.3, “Idiomas para o arquivo” e Secção 10.1.4, “Idiomas para a cópia”) ou para xargs(1) (veja Secção 9.5.9, “Repetindo um ciclo de comandos sobre ficheiros”). Isto pode ser melhorado ao usar os seus argumentos de comando.
A sintaxe básica de find(1) pode ser sumariada no seguinte.
Os seus argumentos condicionais são avaliados da esquerda para a direita.
Esta avaliação pára assim que o seu resultado é determinado.
O "OU lógico" (especificado por
"-o
" entre condicionais) tem precedência mais baixa que o
"E lógico" (especificado por
"-a
" ou nada entre condicionais).
O "NÃO lógico" (especificado por
"!
" antes duma condicional) tem precedência mas alta que
o "E lógico".
"-prune
" retorna sempre o VERDADEIRO lógico e, se for um directório, a busca
de ficheiro é parada para além deste ponto.
"-name
" corresponde à base do nome de ficheiro com glob
de shell (veja Secção 1.5.6, “Glob da shell”) mas também corresponde ao seu
".
" inicial com meta-caracteres como o
"*
" e o "?
". (Nova funcionalidade do
POSIX)
"-regex
" corresponde ao caminho completo com estilo emacs
BRE (veja Secção 1.6.2, “Expressões regulares”) como predefinição.
"-size
" corresponde ao ficheiro baseado no tamanho do
ficheiro (valor precedido de "+
" para maior, precedido de
"-
" para menor)
"-newer
" corresponde ao ficheiro mais recente que aquele
especificado no seu argumento.
"-print0
" retorna sempre o TRUE lógico e escreve o nome de ficheiro completo
(terminado em nulo) na saída standard.
O find(1) é usado geralmente com um estilo idiomático como se segue.
# procura /caminho/para \ -xdev -regextype posix-extended \ -type f -regex ".*\.afio|.*~" -prune -o \ -type d -regex ".*/\.git" -prune -o \ -type f -size +99M -prune -o \ -type f -newer /caminho/para/timestamp -print0
Isto significa fazer as seguintes acções.
Procura todos os ficheiros começando em "/caminho/para
"
limita globalmente a sua busca dentro do sistema de ficheiros inicial e usa ERE (veja antes Secção 1.6.2, “Expressões regulares”)
Exclui da busca os ficheiros que correspondem à expressão regular
".*\.afio
" ou ".*~
" ao parar o
processamento
Exclui da busca os directórios que correspondem à expressão regular
".*/\.git
" ao parar o processamento
Exclui da busca os ficheiros maiores que 99 Mb (unidades de 1048576 bytes) ao parar o processamento
Escreve os nomes de ficheiros que satisfazem as condições de busca em cima e
são mais recentes que "/caminho/para/timestamp
"
Por favor note a utilização idiomática de "-prune -o
"
para excluir ficheiros no exemplo em cima.
![]() |
Nota |
---|---|
Para um sistema não-Debian tipo Unix,
algumas opções podem não ser suportadas pelo
find(1).
Em tal caso, por favor considere ajustar os métodos de correspondência e
substitua " |
Todos nós sabemos que os computadores avaria ou que erros humanos causam danos no sistema e nos dados. As operações de salvaguarda e recuperação são a parte essencial sucesso do administrador de sistemas. Todos os modos de falha possíveis irão atingi-lo um dia.
![]() |
Dica |
---|---|
Mantenha o seu sistema de backup simples e faça backups periódicos. Ter cópias de segurança dos dados é mais importante do que quão bom é tecnicamente o seu método de backup. |
Existem 3 factores chave que determinam a política actual de salvaguarda e recuperação.
Saber o que salvaguardar e recuperar.
Ficheiros de dados criados directamente por si: dados em
"~/
"
Ficheiros de dados criados por aplicações usadas por si: dados em
"/var/
" (excepto "/var/cache/
",
"/var/run/
", e "/var/tmp/
")
Ficheiros de configuração do sistema: dados em "/etc/
"
Softwares locais: dados em "/usr/local/
" ou
"/opt/
"
Informação da instalação do sistema: um memo em texto simples em passos chave (partição, ...)
Conjunto de dados de prova: confirmado com antecedência por operações de recuperação experimentais
Saber como salvaguardar e recuperar
Armazenamento de dados seguro: protecção contra re-escrita e falha do sistema
Salvaguarda frequente: salvaguarda agendada
Backup redundante: usar mirror de dados
Processo à prova de tolos: backup fácil de comando único
Avaliar os riscos e custos envolvidos.
O valor dos dados quando perdidos
Recursos necessários para o backup: humano, hardware, software, ...
Modo de falha e a sua possibilidade
Para o armazenamento seguro de dados, os dados deve estar pelo menos em partições de disco diferentes de preferência em discos e máquinas diferentes para sobreviverem à corrupção do sistema de ficheiros. Os dados importantes ficam melhor armazenados em medias onde só se escreve uma vez, como os CD/DVD-R para prevenir serem sobrescritos por acidente. (veja Secção 10.3, “Os dados binários” para como escrever na media de armazenamento a partir da linha de comandos shell. O ambiente gráfico de trabalho GNOME dá-lhe acesso fácil via menu: "Acessórios→Criador de CD/DVD".)
![]() |
Nota |
---|---|
Você pode desejar parar alguns daemons de aplicação como o MTA (veja Secção 6.3, “Agente de transporte de mail (MTA)”) enquanto faz cópias de segurança (backups) dos dados. |
![]() |
Nota |
---|---|
Você deve ter cuidados extra com o backup e restauro de ficheiros de dados
relacionados com identidade como os
" |
![]() |
Nota |
---|---|
Se você correr uma tarefa cron como um processo de utilizador, você tem de
restaurar os ficheiros no directório
" |
Aqui está uma lista seleccionada de suites de utilitários de backup notáveis disponíveis no sistema Debian.
Tabela 10.3. Lista de suites utilitárias de salvaguarda
pacote | popcon | tamanho | descrição |
---|---|---|---|
rdiff-backup *
|
V:1.3, I:3 | 724 | salvaguarda incremental (remoto) |
dump
*
|
V:0.3, I:1.3 | 716 | 4.4 BSD dump(8) e restore(8) para sistemas de ficheiros ext2/ext3 |
xfsdump *
|
V:0.2, I:2 | 595 | dump e restore com xfsdump(8) e xfsrestore(8) para sistema de ficheiros XFS em GNU/Linux e IRIX |
backupninja *
|
V:0.4, I:0.5 | 267 | sistema de meta-backup leve e extensível |
mondo
*
|
V:0.07, I:0.3 | NOT_FOUND | Mondo Rescue: suite de backup e recuperação de desastres |
sbackup *
|
V:0.04, I:0.10 | 488 | suite de salvaguarda simples para o ambiente GNOME |
keep
*
|
V:0.05, I:0.2 | NOT_FOUND | sistema de salvaguarda para o KDE |
bacula-common *
|
V:1.2, I:2 | 1083 | Bacula: salvaguarda, recuperação e verificação em rede - ficheiros de suporte comum |
bacula-client *
|
I:0.8 | 88 | Bacula: salvaguarda, recuperação e verificação em rede - meta-pacote cliente |
bacula-console *
|
V:0.3, I:1.1 | 154 | Bacula: salvaguarda, recuperação e verificação em rede - consola de texto |
bacula-server *
|
I:0.4 | 88 | Bacula: salvaguarda, recuperação e verificação em rede - meta-pacote servidor |
amanda-common *
|
V:0.3, I:0.7 | 6889 | Amanda: Advanced Maryland Automatic Network Disk Archiver (Bibliotecas) |
amanda-client *
|
V:0.3, I:0.6 | 746 | Amanda: Advanced Maryland Automatic Network Disk Archiver (Cliente) |
amanda-server *
|
V:0.08, I:0.2 | 858 | Amanda: Advanced Maryland Automatic Network Disk Archiver (Servidor) |
backuppc *
|
V:0.7, I:0.9 | 1955 | BackupPC é um sistema de grau empresarial de alta performance para fazer salvaguardas a PCs (baseado em disco) |
backup-manager *
|
V:0.3, I:0.5 | 672 | ferramenta de salvaguarda de linha de comandos |
backup2l *
|
V:0.2, I:0.2 | 120 | ferramenta de baixa manutenção para salvaguarda/restauro para medias montáveis (baseado em disco) |
As ferramentas de salvaguarda têm os seus objectivos especializados.
Mondo Rescue é um sistema de backup para facilitar o restauro de um sistema completo rapidamente a partir de CD/DVD, etc de backup, sem se passar por todo o processo normal de instalação do sistema.
Os pacotes sbackup
e keep
disponibilizam frontends GUI para utilizadores de ambiente de trabalho para
fazerem cópias de segurança regulares dos dados do utilizador. Uma função
equivalente pode ser realizada por um único script (Secção 10.1.8, “Um script de exemplo para salvaguarda ao sistema”) e o
cron(8).
Bacula, Amanda, e BackupPC são suites utilitárias de salvaguarda cheias de funcionalidades que se destinam a salvaguardas regulares em rede.
Ferramentas básicas descritas em Secção 10.1.1, “Ferramentas de arquivo e compressão” e Secção 10.1.2, “Ferramentas de cópia de sincronização” podem ser usadas facilitar o backup do sistema via scripts personalizados. Tal script pode ser melhorado com o seguinte.
O pacote rdiff-backup
permite salvaguardas incrementais
(remotas).
O pacote dump
ajuda a arquivar e restaurar o sistema de
ficheiros completo de modo incremental e eficiente.
![]() |
Dica |
---|---|
Veja os ficheiros em " |
Para um sistema de ambiente de trabalho Debian pessoal que corre a suite
unstable
, Eu apenas preciso de proteger os dados pessoais
e críticos. Eu reinstalo o sistema uma vez por ano de qualquer
maneira. Assim não vejo razão para fazer backup ao sistema completo ou para
instalar um utilitário de backup cheiro de funcionalidades.
Eu uso um script simples para fazer um arquivo salvaguarda e gravá-lo em CD/DVD usando uma GUI. Aqui está um script exemplo para tal.
#!/bin/sh -e # Copyright (C) 2007-2008 Osamu Aoki <osamu@debian.org>, Public Domain BUUID=1000; USER=osamu # UID and name of a user who accesses backup files BUDIR="/var/backups" XDIR0=".+/Mail|.+/Desktop" XDIR1=".+/\.thumbnails|.+/\.?Trash|.+/\.?[cC]ache|.+/\.gvfs|.+/sessions" XDIR2=".+/CVS|.+/\.git|.+/\.svn|.+/Downloads|.+/Archive|.+/Checkout|.+/tmp" XSFX=".+\.iso|.+\.tgz|.+\.tar\.gz|.+\.tar\.bz2|.+\.afio|.+\.tmp|.+\.swp|.+~" SIZE="+99M" DATE=$(date --utc +"%Y%m%d-%H%M") [ -d "$BUDIR" ] || mkdir -p "BUDIR" umask 077 dpkg --get-selections \* > /var/lib/dpkg/dpkg-selections.list debconf-get-selections > /var/cache/debconf/debconf-selections { find /etc /usr/local /opt /var/lib/dpkg/dpkg-selections.list \ /var/cache/debconf/debconf-selections -xdev -print0 find /home/$USER /root -xdev -regextype posix-extended \ -type d -regex "$XDIR0|$XDIR1" -prune -o -type f -regex "$XSFX" -prune -o \ -type f -size "$SIZE" -prune -o -print0 find /home/$USER/Mail/Inbox /home/$USER/Mail/Outbox -print0 find /home/$USER/Desktop -xdev -regextype posix-extended \ -type d -regex "$XDIR2" -prune -o -type f -regex "$XSFX" -prune -o \ -type f -size "$SIZE" -prune -o -print0 } | cpio -ov --null -O $BUDIR/BU$DATE.cpio chown $BUUID $BUDIR/BU$DATE.cpio touch $BUDIR/backup.stamp
Este é suposto ser um script de exemplo executado pelo root.
Eu espero que você altere e execute isto como o seguinte.
Edite este script para cobrir todos os seus dados importantes (veja Secção 10.1.5, “Idiomas para a selecção de ficheiros” e Secção 10.1.6, “Salvaguarda (backup) e recuperação”).
Substitua "find … -print0
" por "find … -newer
$BUDIR/backup.stamp -print0
" para fazer uma salvaguarda
incremental.
Transfira os ficheiros de backup para a máquina remota usando scp(1) ou rsync(1) ou grave-os em CD/DVD para segurança extra dos dados. (Eu uso a GUI do ambiente GNOME para gravar CD/DVD. Veja See Secção 12.1.8, “Exemplo de script de shell com zenity” para redundância extra.)
Mantenha a coisa simples!
![]() |
Dica |
---|---|
Você pode recuperar dados configuração debconf com
" |
Para o conjunto de dados sob uma árvore de directórios, a cópia com
"cp -a
" disponibiliza um backup normal.
Para o conjunto de grandes dados estáticos não-sobrescritos sob uma árvore
de directórios como aquela sob o directório
"/var/cache/apt/packages/
", os hardlinks com "cp
-al
" disponibilizam uma alternativa ao backup normal com uso
eficiente do espaço do disco.
Aqui está um script de cópia, que Eu chamei de bkup
, para
o backup de dados. O script copia todos os ficheiro (não-VCS) sob o
directório actual para o directório datado no directório pai ou numa máquina
remota.
#!/bin/sh -e # Copyright (C) 2007-2008 Osamu Aoki <osamu@debian.org>, Public Domain fdot(){ find . -type d \( -iname ".?*" -o -iname "CVS" \) -prune -o -print0;} fall(){ find . -print0;} mkdircd(){ mkdir -p "$1";chmod 700 "$1";cd "$1">/dev/null;} FIND="fdot";OPT="-a";MODE="CPIOP";HOST="localhost";EXTP="$(hostname -f)" BKUP="$(basename $(pwd)).bkup";TIME="$(date +%Y%m%d-%H%M%S)";BU="$BKUP/$TIME" while getopts gcCsStrlLaAxe:h:T f; do case $f in g) MODE="GNUCP";; # cp (GNU) c) MODE="CPIOP";; # cpio -p C) MODE="CPIOI";; # cpio -i s) MODE="CPIOSSH";; # cpio/ssh S) MODE="AFIOSSH";; # afio/ssh t) MODE="TARSSH";; # tar/ssh r) MODE="RSYNCSSH";; # rsync/ssh l) OPT="-alv";; # hardlink (GNU cp) L) OPT="-av";; # copia (GNU cp) a) FIND="fall";; # procura todos A) FIND="fdot";; # procura não CVS/ .???/ x) set -x;; # trace e) EXTP="${OPTARG}";; # hostname -f h) HOST="${OPTARG}";; # utilizador@maquinaremota.exemplo.com T) MODE="TEST";; # teste ao modo de procura \?) echo "use -x para trace." esac; done shift $(expr $OPTIND - 1) if [ $# -gt 0 ]; then for x in $@; do cp $OPT $x $x.$TIME; done elif [ $MODE = GNUCP ]; then mkdir -p "../$BU";chmod 700 "../$BU";cp $OPT . "../$BU/" elif [ $MODE = CPIOP ]; then mkdir -p "../$BU";chmod 700 "../$BU" $FIND|cpio --null --sparse -pvd ../$BU elif [ $MODE = CPIOI ]; then $FIND|cpio -ov --null | ( mkdircd "../$BU"&&cpio -i ) elif [ $MODE = CPIOSSH ]; then $FIND|cpio -ov --null|ssh -C $HOST "( mkdircd \"$EXTP/$BU\"&&cpio -i )" elif [ $MODE = AFIOSSH ]; then $FIND|afio -ov -0 -|ssh -C $HOST "( mkdircd \"$EXTP/$BU\"&&afio -i - )" elif [ $MODE = TARSSH ]; then (tar cvf - . )|ssh -C $HOST "( mkdircd \"$EXTP/$BU\"&& tar xvfp - )" elif [ $MODE = RSYNCSSH ]; then rsync -rlpt ./ "${HOST}:${EXTP}-${BKUP}-${TIME}" else echo "Mais alguma coisa para salvaguardar?" $FIND |xargs -0 -n 1 echo fi
Isto é suposto ser exemplos de comandos. Por favor, leia o script e edite-o à sua necessidade antes de o usar.
![]() |
Dica |
---|---|
Eu tenho este |
![]() |
Dica |
---|---|
Para fazer um histórico de imagens de uma árvore de ficheiros fonte ou duma árvore de ficheiros de configuração, é mais fácil e eficiente em espaço usar o git(7) (veja Secção 10.9.5, “Git para gravar o histórico de configuração”). |
Dispositivos de armazenamento amovível podem ser qualquer um dos seguintes.
Disco rijo
Qualquer formato de dispositivos de memória flash
Câmara Digital que está ligada via USB, IEEE 1394 / Firewire, PC Card, etc.
Estes dispositivos de armazenamento amovíveis pode ser montados automaticamente como utilizador sob ambientes de trabalho modernos, como o GNOME usando o gnome-mount(1).
O ponto de montagem sob GNOME é escolhido como
"/media/<etiqueta_do_disco>
" o que pode ser
personalizado.
mlabel(1) para o sistema de ficheiros FAT
genisoimage(1)
com a opção "-V
" para o sistema de ficheiros ISO9660
tune2fs(1)
com a opção "-L
" para sistemas de ficheiros ext2/ext3
A escolha de codificação pode necessitar de ser disponibilizada como opção de montagem (veja Secção 8.3.6, “Codificação de nomes de ficheiros”).
O 'dono' do sistema de ficheiros montado pode necessitar de ser ajustado para utilização pelo utilizador normal.
![]() |
Nota |
---|---|
A auto-montagem em ambientes de trabalho modernos apenas acontece quando
esses dispositivos amovíveis não estão listados em
" |
![]() |
Dica |
---|---|
Quando o fornecimento de opções de montagem erradas causar problemas, apague
as suas definições correspondentes sob " |
Tabela 10.4. Lista de pacotes que permitem aos utilizadores normais montarem dispositivos
amovíveis sem uma entrada correspondente no "/etc/fstab
"
pacote | popcon | tamanho | descrição |
---|---|---|---|
gnome-mount *
|
V:3, I:9 | NOT_FOUND | wrapper para (des)montar e ejectar dispositivos de armazenamento (usado pelo GNOME) |
pmount *
|
V:1.9, I:10 | 496 | montar dispositivos amovíveis como utilizador normal (usado pelo KDE) |
cryptmount *
|
V:0.3, I:0.5 | 323 | Gestão e montagem em modo de utilizador de sistemas de ficheiros encriptados |
usbmount *
|
V:0.4, I:1.2 | 116 | montar e desmontar automaticamente dispositivos de armazenamento USB |
Quando partilha dados com outros sistemas via dispositivos de armazenamento amovível, você deve formatá-lo num sistema de ficheiros comum que seja suportado pelos dois sistemas. Aqui está uma lista de escolhas de sistemas de ficheiros.
Tabela 10.5. Lista de hipóteses de sistemas de ficheiros para dispositivos de armazenamento amovíveis com cenários de utilização típica
sistema de ficheiros | descrição do cenário de utilização típico |
---|---|
FAT12 | partilha de dados em várias plataformas em disquetes (<32MiB) |
FAT16 | partilha de dados em várias plataformas em dispositivos como pequenos discos rijos (<2GiB) |
FAT32 | partilha de dados em várias plataformas em dispositivos como grandes discos rijos (<8TiB, suportado por mais recente que MS Windows95 OSR2) |
NTFS | partilha de dados em várias plataformas em dispositivos como grandes discos rijos (suportado nativamente no MS Windows NT e versões posteriores, e suportado pelo NTFS-3G via FUSE em Linux) |
ISO9660 | partilha de dados estáticos em várias plataformas em CD-R e DVD+/-R |
UDF | escrita de dados incremental em CD-R e DVD+/-R (novo) |
sistema de ficheiros MINIX | armazenamento de dados em ficheiros unix eficiente em espaço em disquetes |
sistema de ficheiros ext2 | partilha de dados em dispositivos tipo disco rijo com sistemas Linux mais antigos |
sistema de ficheiros ext3 | partilha de dados em dispositivos tipo disco rijo com sistemas Linux actuais (sistema de ficheiros com journal) |
![]() |
Dica |
---|---|
Veja Secção 9.4.1, “Encriptação de discos amovíveis com dm-crypt/LUKS” para partilha de dados em várias plataformas usando encriptação ao nível do dispositivo. |
O sistema de ficheiros FAT é suportado pela maioria dos sistemas operativos modernos e é bastante útil para objectivos de trocas de dados via dispositivos tipo disco rijo.
Quando formatar dispositivos tipo disco rijo amovíveis para partilha de dados em multi-plataformas com o sistema de ficheiros FAT, as seguintes deverão ser escolhas seguras.
Particioná-los com o fdisk(8), cfdisk(8) ou parted(8) (veja Secção 9.3.2, “Configuração das partições do disco”) numa única partição primária e marcá-la como se segue.
Tipo "6" para FAT16 para médias inferiores a 2GB
Tipo "c" para FAT32 (LBA) para médias maiores
Formatar a partição primária com o mkfs.vfat(8) com o seguinte.
Apenas o seu nome de dispositivo, ex. "/dev/sda1
" para
FAT16
A opção explícita e o seu nome de dispositivo, ex. "-F 32
/dev/sda1
" para FAT32
Quando se usa sistemas de ficheiros FAT ou ISO9660 para partilhar dados, as considerações de segurança deverão ser as seguintes.
Arquivar ficheiros para um ficheiro de arquivo primeiro usando o tar(1), cpio(1), ou o afio(1) para reter o nome de ficheiro longo, o link simbólico, as permissões de ficheiro Unix originais e a informação do dono.
Dividir o ficheiro de arquivo em fatias de menos de 2 GiB com o comando split(1) para o proteger contra limites de tamanho de ficheiro.
Encriptar o ficheiro de arquivo para tornar seguro o seu conteúdo contra acesso não autorizado.
![]() |
Nota |
---|---|
Para o sistema de ficheiros FAT pelo seu desenho, o tamanho máximo de
ficheiro é |
![]() |
Nota |
---|---|
A própria Microsoft não recomenda o uso de FAT para drives ou partições maiores que 200 MB. A Microsoft destaca as suas deficiências como sendo a utilização ineficiente do espaço do disco na sua "Visão geral dos sistemas de ficheiros FAT, HPFS, e NTFS". Claro que, nós devemos normalmente usar o sistema de ficheiros ext3 para Linux. |
![]() |
Dica |
---|---|
Para mais sistemas de ficheiros e acesso a sistemas de ficheiros, por favor leia "HOWTO dos Sistemas de Ficheiros". |
Quando se partilha dados com outro sistema via rede, você deve usar serviços comuns. Aqui estão algumas dicas.
Tabela 10.6. Lista de serviços de rede para escolher com o cenário de utilização típico
serviço de rede | descrição do cenário de utilização típico |
---|---|
SMB/CIFS sistema de ficheiros montado em rede com o Samba |
partilha ficheiros via "Rede Microsoft Windows", veja
smb.conf(5)
e O HOWTO Oficial do Samba
3.2.x e Guia de Referência ou o pacote samba-doc
|
NFS sistema de ficheiros montado em rede com o kernel do Linux. | partilhar ficheiros via "Rede Unix/Linux", veja exports(5) e Linux NFS-HOWTO |
serviço HTTP | partilhando ficheiros entre o servidor/cliente web |
serviço HTTPS | partilhar ficheiros entre o servidor/cliente web com Secure Sockets Layer encriptado (SSL) ou Transport Layer Security (TLS) |
serviço FTP | partilhando ficheiros entre o servidor/cliente FTP |
Apesar de estes sistemas de ficheiros montados sobre rede e métodos de transferência de ficheiros em rede serem bastante convenientes para partilhar dados, estes podem ser inseguros. A sua ligação de rede tem de ser segurada com o seguinte.
Veja também Secção 6.10, “Outras aplicações de servidor de rede” e Secção 6.11, “Outros clientes de aplicação de rede”.
Quando escolher o meio de armazenamento de dados de computador para arquivar dados importantes, deverá ter cuidado com as suas limitações. Para os pequenos backups de dados pessoais, Eu uso CD-R e DVD-R de uma boa marca e guardo-os num ambiente fresco, à sombra, seco e limpo. (O meio de cassete de fita magnética parece ser popular para uso profissional.)
![]() |
Nota |
---|---|
A segurança de resistência ao fogo destina-se a documentos de papel. A maioria dos meios de armazenamento de dados de computador têm menos tolerância à temperatura que o papel. Geralmente Eu confio em múltiplas cópias de segurança encriptadas em múltiplas localizações seguras. |
A duração de vida optimista de meios de arquivo vista na net (a maioria é informação do fabricante).
+ de 100 anos : Papel livre de ácidos com tinta
100 anos : Armazenamento óptico (CD/DVD, CD/DVD-R)
30 anos : Armazenamento magnético (fita, disquete)
20 anos : Armazenamento óptico de mudança de fase (CD-RW)
Estes não contam com falhas mecânicas devido a manuseamento e etc.
Ciclos de escrita optimistas dos meios de arquivo vistos na net (a maioria é informação do fabricante).
+ de 250,000 ciclos : Disco rijo
+ de 10,000 ciclos : Memória Flash
1,000 ciclos : CD/DVD-RW
1 ciclo : CD/DVD-R, papel
![]() |
Cuidado |
---|---|
As figuras de vida de armazenamento e ciclos de escrita mostradas aqui não devem ser usadas para decisões em qualquer armazenamento de dados crítico. Por favor consulte a informação específica do produto disponibilizada pelo fabricante. |
![]() |
Dica |
---|---|
Como os CD/DVD-R e o papel têm apenas 1 ciclo de escrita, eles previnem perdas de dados acidentais ao sobrescrever. Isto é uma vantagem! |
![]() |
Dica |
---|---|
Se você precisa dum backup rápido e frequente de grandes quantidades de dados, um disco rijo numa máquina remota ligada por uma ligação de rede rápida, pode ser a única opção realista. |
Aqui discutimos manipulações da imagem do disco. Veja também Secção 9.3, “Dicas de armazenamento de dados”.
O ficheiro de imagem de disco, "disco.img
", de um
dispositivo não montado, ex., a segunda drive SCSI
"/dev/sdb
", pode ser feito usando o
cp(1)
ou o
dd(1)
com o seguinte.
# cp /dev/sdb disco.img # dd if=/dev/sdb of=disco.img
O master boot record (MBR) da imagem de disco dos PC's tradicionais (veja Secção 9.3.2, “Configuração das partições do disco”) que reside no primeiro sector no disco IDE primário pode ser feito usando o dd(1) com o seguinte.
# dd if=/dev/hda of=mbr.img bs=512 count=1 # dd if=/dev/hda of=mbr-nopart.img bs=446 count=1 # dd if=/dev/hda of=mbr-part.img skip=446 bs=1 count=66
"mbr.img
": O MBR com a tabela de partições
"mbr-nopart.img
": O MBR sem a tabela de partições
"part.img
": A tabela de partições apenas do MBR
Se você tem um dispositivo SCSI (incluindo a nova drive serial ATA) como o
disco de arranque, substitua "/dev/hda
" por
"/dev/sda
".
Se você está a criar uma imagem de uma partição de disco do disco original,
substitua "/dev/hda
" por "/dev/hda1
"
etc.
O ficheiro de imagem de disco "disk.img
" pode ser escrito
para um dispositivo desmontado, ex. a segunda drive SCSI
"/dev/sdb
" como tamanho correspondente, com o seguinte.
# dd if=disk.img of=/dev/sdb
Se modo semelhante, o ficheiro de imagem de partição de disco,
"partition.img
" pode ser escrito para uma partição
desmontada, ex., a primeira partição do segundo disco SCSI
"/dev/sdb1
" com tamanho correspondente, com o seguinte.
# dd if=partition.img of=/dev/sdb1
A imagem de disco "partition.img
" que contém uma partição
única pode ser montada e desmontada ao usar o dispositivo loop como se segue.
# losetup -v -f partition.img Loop device is /dev/loop0 # mkdir -p /mnt/loop0 # mount -t auto /dev/loop0 /mnt/loop0 ...hack...hack...hack # umount /dev/loop0 # losetup -d /dev/loop0
Isto pode ser simplificado como se segue.
# mkdir -p /mnt/loop0 # mount -t auto -o loop partition.img /mnt/loop0 ...hack...hack...hack # umount partition.img
Cada partição da imagem de disco "disk.img
" que contém
múltiplas partições pode ser montada usando o dispositivo loop. Como o dispositivo loop não
gere partições por predefinição, temos que o redefinir como se segue.
# modinfo -p loop # verify kernel capability max_part:Maximum number of partitions per loop device max_loop:Maximum number of loop devices # losetup -a # verify nothing using the loop device # rmmod loop # modprobe loop max_part=16
Agora, o dispositivo loop pode lidar com 16 partições (máximo).
# losetup -v -f disk.img Loop device is /dev/loop0 # fdisk -l /dev/loop0 Disk /dev/loop0: 5368 MB, 5368709120 bytes 255 heads, 63 sectors/track, 652 cylinders Units = cylinders of 16065 * 512 = 8225280 bytes Disk identifier: 0x452b6464 Device Boot Start End Blocks Id System /dev/loop0p1 1 600 4819468+ 83 Linux /dev/loop0p2 601 652 417690 83 Linux # mkdir -p /mnt/loop0p1 # mount -t ext3 /dev/loop0p1 /mnt/loop0p1 # mkdir -p /mnt/loop0p2 # mount -t ext3 /dev/loop0p2 /mnt/loop0p2 ...hack...hack...hack # umount /dev/loop0p1 # umount /dev/loop0p2 # losetup -d /dev/loop0
Alternativamente, podem-se fazer efeitos semelhantes ao usar os dispositivos
device mapper criados pelo
kpartx(8)
do pacote kpartx
como se segue.
# kpartx -a -v disk.img ... # mkdir -p /mnt/loop0p2 # mount -t ext3 /dev/mapper/loop0p2 /mnt/loop0p2 ... ...hack...hack...hack # umount /dev/mapper/loop0p2 ... # kpartx -d /mnt/loop0
![]() |
Nota |
---|---|
Você também pode montar uma única partição de tal imagem de disco com o dispositivo loop usando um offset para saltar o MBR etc. Mas isto é mais inclinado a erros. |
Um ficheiro de imagem de disco, "disk.img
" pode ser limpo
de todos os ficheiros removidos em uma imagem limpa
"new.img
" com o seguinte.
# mkdir old; mkdir new # mount -t auto -o loop disk.img old # dd bs=1 count=0 if=/dev/zero of=new.img seek=5G # mount -t auto -o loop new.img new # cd old # cp -a --sparse=always ./ ../new/ # cd .. # umount new.img # umount disk.img
Se o "disk.img
" está em ext2 ou ext3, você também pode
usar o
zerofree(8)
do pacote zerofree
como se segue.
# losetup -f -v disk.img Loop device is /dev/loop3 # zerofree /dev/loop3 # cp --sparse=always disco.img novo.img
A imagem de disco vazia "disk.img
" que pode crescer até
aos 5GiB pode ser feita usando o
dd(1)
como se segue.
$ dd bs=1 count=0 if=/dev/zero of=disk.img seek=5G
Você pode criar um sistema de ficheiros ext3 nesta imagem de disco
"disk.img
" usando o dispositivo
loop como se segue.
# losetup -f -v disk.img Loop device is /dev/loop1 # mkfs.ext3 /dev/loop1 ...hack...hack...hack # losetup -d /dev/loop1 $ du --apparent-size -h disk.img 5.0G disk.img $ du -h disk.img 83M disk.img
Para "disk.img
", o seu tamanho de ficheiro é 5.0 Gb e a
sua utilização real do disco é apenas 83 Mb. Esta discrepância é possível
porque o ext2fs ponde manter o ficheiro sparse.
![]() |
Dica |
---|---|
A utilização de disco real do ficheiro sparse cresce com os dados que são escritos nele. |
Usando uma operação semelhante em dispositivos criados pelo dispositivo loop ou o mapeador de dispositivos como Secção 10.2.3, “Montar o ficheiro de imagem de disco”, você pode particionar esta imagem
de disco "disk.img
" usando o
parted(8)
ou o
fdisk(8),
e pode criar um sistema de ficheiros nela usando
mkfs.ext3(8),
mkswap(8),
etc.
O ficheiro de imagem ISO9660,
"cd.iso
", a partir da árvore de directórios fonte em
"source_directory
" pode ser feito usando o
genisoimage(1)
disponibilizado pelo cdrkit com o seguinte.
# genisoimage -r -J -T -V volume_id -o cd.iso directório_fonte
De modo semelhante, o ficheiro de imagem ISO9660 de arranque,
"cdboot.iso
", pode ser feito a partir do
instalador-debian
como árvore de directórios em
"source_directory
" com o seguinte.
# genisoimage -r -o cdboot.iso -V volume_id \ -b isolinux/isolinux.bin -c isolinux/boot.cat \ -no-emul-boot -boot-load-size 4 -boot-info-table directório_fonte
Aqui é usado para arranque o boot loader Isolinux (veja Secção 3.3, “Estágio 2: o gestor de arranque (boot loader)”).
Você pode calcular o valor md5sum e fazer a imagem ISO9660 directamente a partir do dispositivo CD-ROM como se segue.
$ isoinfo -d -i /dev/cdrom CD-ROM is in ISO 9660 format ... Logical block size is: 2048 Volume size is: 23150592 ... # dd if=/dev/cdrom bs=2048 count=23150592 conv=notrunc,noerror | md5sum # dd if=/dev/cdrom bs=2048 count=23150592 conv=notrunc,noerror > cd.iso
![]() |
Atenção |
---|---|
Você tem de ter o cuidado de evitar o bug de leitura antecipada do sistema de ficheiros ISO9660 do Linux como em cima para obter o resultado correcto. |
![]() |
Dica |
---|---|
Um DVD é apenas um CD grande para o wodim(1) disponibilizado pelo cdrkit. |
Você pode procurar um dispositivo utilizável com o seguinte.
# wodim --devices
Então o CD-R vazio é inserido na drive de CD, e o ficheiro de imagem
ISO9660, "cd.iso
" é escrito neste dispositivo,
ex. "/dev/hda
", usando o
wodim(1)
com o seguinte.
# wodim -v -eject dev=/dev/hda cd.iso
Se for usado um CD-RW em vez de um CD-R, faça antes o seguinte.
# wodim -v -eject blank=fast dev=/dev/hda cd.iso
![]() |
Dica |
---|---|
Se o seu ambiente montar CDs automaticamente, desmonte-o com " |
Se "cd.iso
" conter uma imagem ISO9660, então o seguinte
monta-o manualmente em "/cdrom
".
# mount -t iso9660 -o ro,loop cd.iso /cdrom
![]() |
Dica |
---|---|
Os sistemas de ambiente de trabalho modernos montam medias amovíveis automaticamente (veja Secção 10.1.10, “Dispositivo de armazenamento amovível”). |
Aqui, discutimos manipulação directa de dados binários em medias de armazenamento. Veja também Secção 9.3, “Dicas de armazenamento de dados”.
o método de visualização mais básico de dados binários é usar o comando
"od -t x1
".
Tabela 10.7. Lista de pacote para ver e editar dados binários
pacote | popcon | tamanho | descrição |
---|---|---|---|
coreutils *
|
V:90, I:99 | 13477 | pacote básico que tem od(1) para despejar ficheiros (HEX, ASCII, OCTAL, …) |
bsdmainutils *
|
V:84, I:99 | 764 | pacote utilitário que tem hd(1) para despejar ficheiros (HEX, ASCII, OCTAL, …) |
hexedit *
|
V:0.2, I:1.7 | 108 | editor binário e visualizador (HEX, ASCII) |
bless
*
|
V:0.08, I:0.4 | 1180 | editor hexadecimal cheiro de funcionalidades (GNOME) |
okteta *
|
V:0.6, I:4 | 440 | editor hexadecimal cheiro de funcionalidades (KDE4) |
ncurses-hexedit *
|
V:0.07, I:0.5 | 192 | editor binário e visualizador (HEX, ASCII, EBCDIC) |
lde
*
|
V:0.04, I:0.2 | 992 | Editor de Disco de Linux |
beav
*
|
V:0.03, I:0.2 | 164 | editor binário e visualizador (HEX, ASCII, EBCDIC, OCTAL, …) |
hex
*
|
V:0.01, I:0.06 | NOT_FOUND | ferramenta de despejo hexadecimal (suporta códigos de 2 bytes Japoneses) |
![]() |
Dica |
---|---|
HEX é usado como um acrónimo para o formato hexadecimal com radix 16. OCTAL é para formato octal com radix 8. ASCII é para American Standard Code for Information Interchange, isto é, código de texto Inglês normal. EBCDIC é para Extended Binary Coded Decimal Interchange Code usado em sistemas operativos com infraestrutura da IBM. |
Existem ferramentas para ler e escrever ficheiros sem montar o disco.
Os sistemas RAID por software oferecidos pelo kernel Linux oferecem redundância de dados ao nível do sistema de ficheiros do kernel, para se conseguir altos níveis de fiabilidade de armazenamento.
Também existem ferramentas para adicionar redundância a ficheiros ao nível de programa aplicação, para se conseguir altos níveis de fiabilidade de armazenamento.
Tabela 10.9. Lista de ferramentas para adicionar redundância de dados a ficheiros
pacote | popcon | tamanho | descrição |
---|---|---|---|
par2
*
|
V:0.5, I:1.7 | 272 | Parity Archive Volume Set, para verificação e reparação de ficheiros |
dvdisaster *
|
V:0.11, I:0.6 | 1388 | protecção de dados contra percas/riscos/envelhecimento para medias CD/DVD |
dvbackup *
|
V:0.01, I:0.06 | 544 | ferramenta de backup que usa câmaras de filmar MiniDV (disponibilizando rsbep(1)) |
vdmfec *
|
V:0.00, I:0.02 | 88 | recuperar blocos perdidos usando o Forward Error Correction |
Existem ferramentas para recuperação de ficheiros e dados e análise forense.
Tabela 10.10. Lista de pacotes para recuperação de ficheiros e dados e análise forense
pacote | popcon | tamanho | descrição |
---|---|---|---|
testdisk *
|
V:0.3, I:3 | 4620 | utilitários para sondagem de partições e recuperação de discos |
magicrescue *
|
V:0.06, I:0.4 | 344 | utilitário para recuperar ficheiros ao procurar por bytes mágicos |
scalpel *
|
V:0.04, I:0.3 | 124 | frugal, entalhador de ficheiros de alta performance |
myrescue *
|
V:0.02, I:0.16 | 84 | recuperar dados de discos rijos danificados |
recover *
|
V:0.05, I:0.5 | 104 | utilitários para recuperar ficheiros apagados no sistema de ficheiros ext2 |
e2undel *
|
V:0.03, I:0.4 | 244 | utilitários para recuperar ficheiros apagados no sistema de ficheiros ext2 |
ext3grep *
|
V:0.08, I:0.6 | 296 | ferramenta para ajudar a recuperar ficheiros apagados no sistema de ficheiros ext3 |
scrounge-ntfs *
|
V:0.02, I:0.3 | 80 | programa de recuperação de dados para sistemas de ficheiros NTFS |
gzrt
*
|
V:0.00, I:0.11 | 68 | conjunto de ferramentas de recuperação gzip |
sleuthkit *
|
V:0.11, I:0.5 | 750 | ferramentas para análise forense. (Sleuthkit) |
autopsy *
|
V:0.05, I:0.3 | 1372 | interface gráfica para o SleuthKit |
foremost *
|
V:0.11, I:0.8 | 140 | aplicação forense para recuperar dados |
guymager *
|
V:0.00, I:0.03 | 852 | ferramenta de imagem forense baseada em Qt |
tct
*
|
V:0.02, I:0.15 | NOT_FOUND | utilitários relacionados com forenses |
dcfldd *
|
V:0.03, I:0.2 | 124 |
versão melhorada do dd para forenses e segurança
|
rdd
*
|
V:0.01, I:0.10 | 200 | programa de cópia forense |
Quando os dados são muito grandes para fazer backup num ficheiro único, você pode fazer backup ao seu conteúdo após dividi-lo em fatias de, por exemplo, 2000Mb e mais tarde fundir essas fatias de volta para o ficheiro original.
$ split -b 2000m ficheiro_grande $ cat x* >ficheiro_grande
![]() |
Cuidado |
---|---|
Por favor certifique-se que não tem nenhuns ficheiros que começam com
" |
De modo a limpar o conteúdo de um ficheiro como um ficheiro log, não use o rm(1) para apagar o ficheiro e depois crie um ficheiro vazio, porque o ficheiro pode ainda estar a ser acedido no intervalo entre comandos. O seguinte é o modo seguro de limpar o conteúdo do ficheiro.
$ :>ficheiro_a_ser_limpo
Os seguintes comandos criam ficheiros dummy ou vazios.
$ dd if=/dev/zero of=5kb.file bs=1k count=5 $ dd if=/dev/urandom of=7mb.file bs=1M count=7 $ touch zero.file $ : > alwayszero.file
Você deve encontrar os seguintes ficheiros.
"5kb.file
" é 5KB de zeros.
"7mb.file
" são 7MB de dados aleatórios.
"zero.file
" pode ser um ficheiro de 0 bytes. Se existir,
o seu mtime
é actualizado enquanto o seu conteúdo e
tamanho são mantidos.
"alwayszero.file
" é sempre um ficheiro de 0 bytes. Se
existir, o seu mtime
é actualizado e o seu conteúdo é
reposto.
Existem várias maneiras de apagar completamente os dados de um dispositivo
inteiro tipo disco rijo, ex., stick de memória USB em
"/dev/sda
".
![]() |
Cuidado |
---|---|
Primeiro verifique a localização da sua caneta de memória USB com o
mount(8)
antes de executar os comandos aqui. O dispositivo apontado por
" |
Apagar todo o conteúdo do disco ao repor os dados a 0 com o seguinte.
# dd if=/dev/zero of=/dev/sda
Apagar tudo ao sobrescrever dados aleatórios com o seguinte.
# dd if=/dev/urandom of=/dev/sda
Apagar tudo ao sobrescrever dados aleatórios muito eficientemente com o seguinte.
# shred -v -n 1 /dev/sda
Como o
dd(1)
está disponível a partir da shell de muitos CDs de arranque de Linux como o
CD de instalação de Debian, você pode apagar completamente o seu sistema
instalado no disco rijo, por exemplo, "/dev/hda
",
"/dev/sda
", etc., ao correr um comando de limpeza a
partir de tal media de arranque.
A área não utilizada de um disco rijo (ou duma caneta de memória USB), por
exemplo "/dev/sdb1
" pode ainda conter os próprios dados
apagados pois eles são apenas 'desligados' do sistema de ficheiros. Estes
podem ser limpos ao sobrescrever a área onde estão.
# mount -t auto /dev/sdb1 /mnt/foo # cd /mnt/foo # dd if=/dev/zero of=junk dd: writing to `junk': No space left on device ... # sync # umount /dev/sdb1
![]() |
Atenção |
---|---|
Normalmente isto é suficientemente bom para o seu stick de memória USB. Mas não é perfeito. A maioria das partes dos nomes de ficheiros apagados e os seus atributos podem ficar escondidos e permanecerem no sistema de ficheiros. |
Mesmo que tenha acidentalmente apagado um ficheiro, desde que esse ficheiro esteja ainda a ser usado por alguma aplicação (em modo de leitura ou escrita), é possível recuperar tal ficheiro.
Por exemplo, tente o seguinte
$ echo foo > bar $ less bar $ ps aux | grep ' less[ ]' bozo 4775 0.0 0.0 92200 884 pts/8 S+ 00:18 0:00 less bar $ rm bar $ ls -l /proc/4775/fd | grep bar lr-x------ 1 bozo bozo 64 2008-05-09 00:19 4 -> /home/bozo/bar (apagado) $ cat /proc/4775/fd/4 >bar $ ls -l -rw-r--r-- 1 bozo bozo 4 2008-05-09 00:25 bar $ cat bar foo
Execute em outro terminal (quando tem o pacote lsof
instalado) o seguinte.
$ ls -li bar 2228329 -rw-r--r-- 1 bozo bozo 4 2008-05-11 11:02 bar $ lsof |grep bar|grep less less 4775 bozo 4r REG 8,3 4 2228329 /home/bozo/bar $ rm bar $ lsof |grep bar|grep less less 4775 bozo 4r REG 8,3 4 2228329 /home/bozo/bar (apagado) $ cat /proc/4775/fd/4 >bar $ ls -li bar 2228302 -rw-r--r-- 1 bozo bozo 4 2008-05-11 11:05 bar $ cat bar foo
Os ficheiros com hardlinks podem ser identificados com "ls
-li
".
$ ls -li total 0 2738405 -rw-r--r-- 1 root root 0 2008-09-15 20:21 bar 2738404 -rw-r--r-- 2 root root 0 2008-09-15 20:21 baz 2738404 -rw-r--r-- 2 root root 0 2008-09-15 20:21 foo
Ambos "baz
" e "foo
" têm contagens de
link de "2" (>1) mostrando que têm hardlinks. Os números de inode deles são comuns "2738404". Isto significa que
eles são o mesmo ficheiro em hardlink. Se você não encontrar todos os
ficheiros em hardlink por acaso, pode procurá-los pelo inode, ex., "2738404" com o seguinte.
# find /caminho/para/ponto/de/montagem -xdev -inum 2738404
A infraestrutura de segurança dos dados é disponibilizada pela combinação de uma ferramenta de encriptação de dados, ferramenta de resumo de mensagens, e ferramenta de assinaturas.
Tabela 10.11. Lista de ferramentas de infraestrutura da segurança de dados
comando | pacote | popcon | tamanho | descrição |
---|---|---|---|---|
gpg(1) |
gnupg
*
|
V:89, I:99 | 5232 | GNU Privacy Guard - ferramenta de encriptação e assinatura OpenPGP |
N/D |
gnupg-doc *
|
I:0.9 | 4124 | Documentação do GNU Privacy Guard |
gpgv(1) |
gpgv
*
|
V:60, I:99 | 436 | GNU Privacy Guard - ferramenta de verificação de assinaturas |
paperkey(1) |
paperkey *
|
V:0.01, I:0.07 | 88 | extrai apenas a informação secreta de chaves secretas OpenPGP |
cryptsetup(8), … |
cryptsetup *
|
V:4, I:6 | 740 | utilitários para encriptação de dispositivos de bloco do dm-crypto que suportam LUKS |
ecryptfs(7), … |
ecryptfs-utils *
|
V:0.3, I:0.4 | 372 | utilitários para encriptação de sistemas de ficheiros empilhados do ecryptfs |
md5sum(1) |
coreutils *
|
V:90, I:99 | 13477 | computa e verifica o resumo da mensagem MD5 |
sha1sum(1) |
coreutils *
|
V:90, I:99 | 13477 | computa e verifica o resumo da mensagem SHA1 |
openssl(1ssl) |
openssl *
|
V:69, I:95 | 1053 |
computa o resumo da mensagem com "openssl dgst " (OpenSSL)
|
Veja Secção 9.4, “Dicas de encriptação de dados” em dm-crypto e ecryptfs os quais implementam infraestruturas de encriptação de dados automática via módulos do kernel Linux.
Aqui estão comandos do GNU Privacy Guard para gestão de chaves básica.
Tabela 10.12. Lista de comandos do GNU Privacy Guard para gestão de chaves
comando | descrição |
---|---|
gpg --gen-key
|
gerar uma chave nova |
gpg --gen-revoke meu_ID_utilizador
|
gera chave de revogação para meu_ID_utilizador |
gpg --edit-key ID_utilizador
|
edita chave interactivamente, "help" para ajuda |
gpg -o ficheiro --exports
|
exporta todas as chaves para ficheiro |
gpg --imports ficheiro
|
importa todas as chaves de ficheiro |
gpg --send-keys ID_utilizador
|
envia chave de ID_utilizador para servidor de chaves |
gpg --recv-keys ID_utilizador
|
recupera chave de ID_utilizador do servidor de chaves |
gpg --list-keys ID_utilizador
|
lista chaves de ID_utilizador |
gpg --list-sigs ID_utilizador
|
lista assinaturas de ID_utilizador |
gpg --check-sigs ID_utilizador
|
verifica assinaturas de ID_utilizador |
gpg --fingerprint ID_utilizador
|
verifica a impressão digital de ID_utilizador |
gpg --refresh-keys
|
actualiza o chaveiro local |
Aqui está o significado do código de confiança
Tabela 10.13. Lista do significado do código de confiança
código | descrição de confiança |
---|---|
-
|
nenhuma confiança de dono atribuída / ainda não calculado |
e
|
falha no cálculo da confiança |
q
|
não existe informação suficiente para o cálculo |
n
|
nunca confiar nesta chave |
m
|
marginalmente confiável |
f
|
totalmente confiável |
u
|
de confiança absoluta |
O seguinte envia a minha chave "1DD8D791
" para o popular
servidor de chaves "hkp://keys.gnupg.net
".
$ gpg --keyserver hkp://keys.gnupg.net --send-keys 1DD8D791
Um bom servidor de chaves predefinido configurado em
"~/.gnupg/gpg.conf
" (ou na antiga localização
"~/.gnupg/options
") contém o seguinte.
keyserver hkp://keys.gnupg.net
O seguinte obtém chaves desconhecidas do servidor de chaves.
$ gpg --list-sigs --with-colons | grep '^sig.*\[User ID not found\]' |\ cut -d ':' -f 5| sort | uniq | xargs gpg --recv-keys
Existiu um bug no OpenPGP Public Key
Server (versão anterior a 0.9.6) que corrompeu as chaves com mais de
2 sub-chaves. O novo pacote gnupg
(>1.2.1-2) consegue
lidar com estas chaves corrompidas. Veja
gpg(1)
sob a opção "--repair-pks-subkey-bug
".
Aqui estão exemplos para usar comandos do GNU Privacy Guard em ficheiros.
Tabela 10.14. Lista de comandos do GNU Privacy Guard em ficheiros
comando | descrição |
---|---|
gpg -a -s ficheiro
|
assina ficheiro em ficheiro.asc blindado de ASCII |
gpg --armor --sign ficheiro
|
, , |
gpg --clearsign ficheiro
|
mensagem com assinatura clara |
gpg --clearsign file|mail foo@example.org
|
envia por mail uma mensagem com assinatura clara para
foo@example.org
|
gpg --clearsign --not-dash-escaped patchfile
|
ficheiro patch com assinatura clara |
gpg --verify ficheiro
|
verifica ficheiro com assinatura clara |
gpg -o ficheiro.sig -b ficheiro
|
cria assinatura separada |
gpg -o ficheiro.sig --detach-sig ficheiro
|
, , |
gpg --verify ficheiro.sig ficheiro
|
verifica ficheiro com file.sig |
gpg -o crypt_file.gpg -r nome -e ficheiro
|
encriptação de chave pública destinada a nome a partir de ficheiro para crypt_file.gpg binário |
gpg -o crypt_file.gpg --recipient nome --encrypt ficheiro
|
, , |
gpg -o crypt_file.asc -a -r nome -e ficheiro
|
encriptação de chave pública destinada a nome a partir de ficheiro para crypt_file.asc blindado de ASCII |
gpg -o crypt_file.gpg -c ficheiro
|
encriptação simétrica a partir de ficheiro para crypt_file.gpg |
gpg -o crypt_file.gpg --symmetric ficheiro
|
, , |
gpg -o crypt_file.asc -a -c ficheiro
|
encriptação simétrica destinada a nome a partir de ficheiro para crypt_file.asc blindado de ASCII |
gpg -o ficheiro -d crypt_file.gpg -r nome
|
desencriptação |
gpg -o ficheiro --decrypt crypt_file.gpg
|
, , |
Adicione o seguinte a "~/.muttrc
" para impedir o GnuPG
lento de arrancar automaticamente, enquanto permite que seja usado ao
escrever "S
" no menu de índice.
macro index S ":toggle pgp_verify_sig\n" set pgp_verify_sig=no
O plugin do gnupg
permite-lhe correr o GnuPG
transparentemente para ficheiros com extensão ".gpg
",
".asc
", e ".ppg
".
# aptitude install vim-scripts vim-addon-manager $ vim-addons install gnupg
O md5sum(1) disponibiliza um utilitário para fazer um ficheiro de sumário usando o método em rfc1321 e verificar cada ficheiro com ele.
$ md5sum foo bar >baz.md5 $ cat baz.md5 d3b07384d113edec49eaa6238ad5ff00 foo c157a79031e1c40f85931829bc5fc552 bar $ md5sum -c baz.md5 foo: OK bar: OK
![]() |
Nota |
---|---|
O cálculo do sumário MD5 é menos intensivo para a CPU que o da assinatura criptográfica do GNU Privacy Guard (GnuPG). Normalmente, apenas o ficheiro de digestão do nível de topo é assinado criptograficamente para assegurar a integridade dos dados. |
Existem muitas ferramentas de fusão para código fonte. Os seguinte comandos chamaram a minha atenção.
Tabela 10.15. Lista de ferramentas de fusão de código fonte
comando | pacote | popcon | tamanho | descrição |
---|---|---|---|---|
diff(1) |
diff
*
|
V:30, I:47 | 31 | compara ficheiros linha a linha |
diff3(1) |
diff
*
|
V:30, I:47 | 31 | compara e funde três ficheiros linha a linha |
vimdiff(1) |
vim
*
|
V:16, I:37 | 1829 | compara dois ficheiros lado a lado no vim |
patch(1) |
patch
*
|
V:13, I:93 | 248 | aplica ficheiro diff a um original |
dpatch(1) |
dpatch *
|
V:0.8, I:8 | 141 | gere séries de patches para pacote Debian |
diffstat(1) |
diffstat *
|
V:2, I:15 | 92 | produz um histograma de alterações feitas pelo diff |
combinediff(1) |
patchutils *
|
V:1.8, I:12 | 296 | cria uma patch cumulativa de duas patches incrementais |
dehtmldiff(1) |
patchutils *
|
V:1.8, I:12 | 296 | extrai um diff de uma página HTML |
filterdiff(1) |
patchutils *
|
V:1.8, I:12 | 296 | extrai ou executa diffs de um ficheiro diff |
fixcvsdiff(1) |
patchutils *
|
V:1.8, I:12 | 296 | corrige ficheiros diff criados pelo CVS que o patch(1) interpreta mal |
flipdiff(1) |
patchutils *
|
V:1.8, I:12 | 296 | troca a ordem de duas patches |
grepdiff(1) |
patchutils *
|
V:1.8, I:12 | 296 | mostra que ficheiros são modificados por uma patch que corresponde a um regex |
interdiff(1) |
patchutils *
|
V:1.8, I:12 | 296 | mostra as diferenças entre dois ficheiros diff unificados |
lsdiff(1) |
patchutils *
|
V:1.8, I:12 | 296 | mostra quais ficheiros são modificados por uma patch |
recountdiff(1) |
patchutils *
|
V:1.8, I:12 | 296 | recalcula contagens e offsets em diffs de contexto unificado |
rediff(1) |
patchutils *
|
V:1.8, I:12 | 296 | corrige os offsets e as contagens de um diff editado manualmente |
splitdiff(1) |
patchutils *
|
V:1.8, I:12 | 296 | separa patches incrementais |
unwrapdiff(1) |
patchutils *
|
V:1.8, I:12 | 296 | desembaralha patches cujas linhas foram alteradas para arrumação de palavras |
wiggle(1) |
wiggle *
|
V:0.01, I:0.07 | 232 | aplica patches rejeitadas |
quilt(1) |
quilt
*
|
V:1.5, I:10 | 719 | gere séries de patches |
meld(1) |
meld
*
|
V:1.0, I:3 | 2076 | compara e funde ficheiros (GTK) |
xxdiff(1) |
xxdiff *
|
V:0.2, I:1.3 | 1352 | compara e funde ficheiros (X simples) |
dirdiff(1) |
dirdiff *
|
V:0.08, I:0.5 | 224 | mostra diferenças e funde alterações entre árvores de directórios |
docdiff(1) |
docdiff *
|
V:0.01, I:0.10 | 692 | compara dois ficheiros palavra a palavra / caractere a caractere |
imediff2(1) |
imediff2 *
|
V:0.01, I:0.08 | 76 | ferramenta de fusão de 2 vias interactiva de écran completo |
makepatch(1) |
makepatch *
|
V:0.01, I:0.13 | 148 | gera ficheiros de patch extensos |
applypatch(1) |
makepatch *
|
V:0.01, I:0.13 | 148 | aplica ficheiros de patch extensos |
wdiff(1) |
wdiff
*
|
V:1.5, I:13 | 984 | mostra diferenças de palavras entre ficheiros de texto |
Um dos seguintes procedimentos extrai as diferenças entre dois ficheiros de
fonte e cria os ficheiros diff unificados "file.patch0
"
ou "file.patch1
" dependendo da localização do ficheiro.
$ diff -u ficheiro.antigo ficheiro.novo > ficheiro.patch0 $ diff -u antigo/ficheiro novo/ficheiro > ficheiro.patch1
O ficheiro diff (alternativamente chamado ficheiro patch) é usado para enviar uma actualização de um programa. A parte receptora aplica esta actualização a outro ficheiro com o seguinte.
$ patch -p0 ficheiro < ficheiro.patch0 $ patch -p1 ficheiro < ficheiro.patch1
Aqui está um sumário dos sistemas de controle de versão (VCS) no sistema Debian.
![]() |
Nota |
---|---|
Se você é novato nos sistemas VCS, deverá começar a aprender com o Git, o qual está a crescer rapidamente na popularidade. |
Tabela 10.16. lista de ferramentas de sistemas de controle de versão
pacote | popcon | tamanho | ferramenta | Tipo VCS | comentário |
---|---|---|---|---|---|
cssc
*
|
V:0.00, I:0.03 | 2240 | CSSC | local | clone do SCCS do Unix (descontinuado) |
rcs
*
|
V:0.9, I:5 | 772 | RCS | local | "SCCS do Unix bem feito" |
cvs
*
|
V:2, I:15 | 4352 | CVS | remoto | VCS remoto standard anterior |
subversion *
|
V:8, I:29 | 4107 | Subversion | remoto | "CVS bem feito", o novo VCS remoto standard "de facto" |
git
*
|
V:10, I:35 | 10625 | Git | distribuído | DVCS rápido em C (usado pelo kernel Linux e outros) |
mercurial *
|
V:1.9, I:7 | 336 | Mercurial | distribuído | DVCS em Python e algum C |
bzr
*
|
V:1.1, I:4 | 61 | Bazaar | distribuído |
DVCS influenciado por tla escrito em Python (usado pelo
Ubuntu)
|
darcs
*
|
V:0.2, I:1.1 | 10987 | Darcs | distribuído | DVCS com algebra inteligente de patches (lento) |
tla
*
|
V:0.15, I:1.2 | 881 | GNU arch | distribuído | DVCS principalmente por Tom Lord (Histórico) |
monotone *
|
V:0.04, I:0.2 | 5346 | Monotone | distribuído | DVCS em C++ |
tkcvs
*
|
V:0.08, I:0.3 | 2476 | CVS, … | remoto | Mostrador GUI de árvores de repositório VCS (CVS, Subversion, RCS) |
gitk
*
|
V:0.9, I:5 | 1015 | Git | distribuído | Mostrador GUI de árvores de repositório VCS (Git) |
O VCS é por vezes conhecido como um sistema de controle de revisão (RCS), ou gestão de configuração de software (SCM).
O VCS distribuído como o Git é a ferramenta escolhida nos dias de hoje. O CVS e Subversion podem ainda ser úteis para juntar algumas actividades de programas de código aberto existentes.
O Debian disponibiliza serviços VCS livres via serviço Debian Alioth. Suporta praticamente todos os VCSs. A sua documentação pode ser encontrada em http://wiki.debian.org/Alioth.
![]() |
Cuidado |
---|---|
O pacote |
Existem algumas bases para criar um arquivo VCS de acesso partilhado.
Use "umask 002
" (veja Secção 1.2.4, “Control de permissões para ficheiros acabados de criar: umask”)
Tornar todos os ficheiros de arquivo VCS pertencentes a um grupo pertinente.
Activar a definição de ID de grupo em todos os directórios do arquivo VCS (esquema de criação de ficheiros do tipo BSD, veja Secção 1.2.3, “Permissões do sistema de ficheiros”)
Fazer o utilizador que partilha o arquivo VCS pertencer ao grupo
Aqui está uma comparação muito simplificada dos comandos VCS nativos para disponibilizar a ideia geral. A sequência de comandos típica pode requerer opções e argumentos.
Tabela 10.17. Comparação dos comandos VCS nativos
CVS | Subversion | Git | função |
---|---|---|---|
cvs init
|
svn create
|
git init
|
cria o repositório (local) |
cvs login
|
- | - | login ao repositório remoto |
cvs co
|
svn co
|
git clone
|
faz check out ao repositório remoto como a árvore de trabalho |
cvs up
|
svn up
|
git pull
|
actualiza a árvore de trabalho ao fundir o repositório remoto |
cvs add
|
svn add
|
git add .
|
adiciona ficheiro(s) na árvore de trabalho do VCS |
cvs rm
|
svn rm
|
git rm
|
remove ficheiro(s) na árvore de trabalho do VCS |
cvs ci
|
svn ci
|
- | comete alterações para o repositório remoto |
- | - |
git commit -a
|
comete alterações para o repositório local |
- | - |
git push
|
actualiza o repositório remoto pelo repositório local |
cvs status
|
svn status
|
git status
|
mostra o estado da árvore de trabalho do VCS |
cvs diff
|
svn diff
|
git diff
|
diff <repositório_referência> <árvore_de_trabalho> |
- | - |
git repack -a -d; git prune
|
re-empacota o repositório local em um único pacote |
tkcvs
|
tkcvs
|
gitk
|
Mostrador GUI de árvore de repositório VCS |
![]() |
Cuidado |
---|---|
Invocar um sub-comando |
![]() |
Dica |
---|---|
Ferramentas GUI como o tkcvs(1) e gitk(1) ajudam-no realmente com o acompanhamento do histórico de revisão dos ficheiros. A interface web disponibiliza por muitos arquivos públicos para exploração dos seus repositórios é também muito útil. |
![]() |
Dica |
---|---|
O git pode trabalhar directamente com diferentes repositórios CVS como
aqueles disponibilizados pelo CVS e Subversion, e disponibiliza o
repositório local para alterações locais com os pacotes
|
![]() |
Dica |
---|---|
Git tem comandos que não têm equivalentes em CVS e Subversion: "fetch", "rebase", "cherry-pick", … |
Veja o seguinte.
cvs(1)
"/usr/share/doc/cvs/html-cvsclient
"
"/usr/share/doc/cvs/html-info
"
"/usr/share/doc/cvsbook
"
"info cvs
"
A seguinte configuração permite submissões para o repositório CVS apenas por
um membro do grupo "src
", e administração do CVS apenas
por um membro do grupo "staff
", assim reduzindo as
hipóteses de dar um tiro em si próprio.
# cd /var/lib; umask 002; mkdir cvs # export CVSROOT=/srv/cvs/project # cd $CVSROOT # chown root:src . # chmod 2775 . # cvs -d $CVSROOT init # cd CVSROOT # chown -R root:staff . # chmod 2775 . # touch val-tags # chmod 664 history val-tags # chown root:src history val-tags
![]() |
Dica |
---|---|
Você pode restringir a criação de novo projecto ao alterar o dono do
directório " |
O repositório CVS predefinido é apontado por
"$CVSROOT
". O seguinte define
"$CVSROOT
" para o acesso local.
$ export CVSROOT=/srv/cvs/project
Muitos servidores CVS públicos disponibilizam acesso remoto apenas de
leitura a eles com o nome de conta "anonymous
" via
serviço pserver. Por exemplo, os conteúdos do site web de Debian são
mantidos pelo projecto webwml via CVS
no serviço alioth de Debian. O seguinte configura
"$CVSROOT
" para o acesso remoto a este repositório CVS.
$ export CVSROOT=:pserver:anonymous@cvs.alioth.debian.org:/cvsroot/webwml $ cvs login
![]() |
Nota |
---|---|
Como o pserver é inclinado a ataques de escutas e inseguro, o acesso de escrita geralmente é desactivado pelos administradores do servidor. |
O seguinte configura "$CVS_RSH
" e
"$CVSROOT
" para o acesso remoto ao repositório CVS pelo
projecto webwml com SSH.
$ export CVS_RSH=ssh $ export CVSROOT=:ext:account@cvs.alioth.debian.org:/cvs/webwml
Você também pode usar autenticação de chave pública para SSH o que elimina o pedido remoto de palavra-passe.
Crie uma nova localização de árvore fonte local em
"~/caminho/para/module1
" com o seguinte.
$ mkdir -p ~/caminho/para/module1; cd ~/caminho/para/module1
Povoa uma nova árvore fonte local sob
"~/caminho/para/module1
" como ficheiros.
Importe-o para o CVS com os seguintes parâmetros.
Module name: "module1
"
Vendor tag: "Main-branch
" (etiqueta para o branch
completo)
Release tag: "Release-initial
" (etiqueta para um
lançamento específico)
$ cd ~/caminho/para/module1 $ cvs import -m "Start module1" module1 Main-branch Release-initial $ rm -Rf . # opcional
O CVS não sobrescreve o ficheiro do repositório actual mas substitui-o por
outros. Assim, a permissão de escrita no directório do repositório é
crítica. Para cada novo módulo para "module1
" no
repositório em "/srv/cvs/project
", corra o seguinte para
assegurar esta condição se necessário.
# cd /srv/cvs/project # chown -R root:src module1 # chmod -R ug+rwX module1 # chmod 2775 module1
Aqui está um exemplo de um fluxo de trabalho típico usando CVS
Verifique todos os módulos disponíveis do projecto CVS apontados por
"$CVSROOT
" com o seguinte.
$ cvs rls CVSROOT module1 module2 ...
Faça o checkout a "module1
" para o seu directório
predefinido "./module1
" com o seguinte.
$ cd ~/caminho/para $ cvs co module1 $ cd module1
Faça as alterações necessárias ao conteúdo.
Verifique alterações ao fazer "diff -u [repositório]
[local]
" equivalente ao seguinte.
$ cvs diff -u
Você descobre que danificou o ficheiro
"ficheiro-a-desfazer
" severamente mas os outros ficheiros
estão bem.
Sobrescreva o ficheiro "ficheiro-a-desfazer
" com uma
cópia limpa do CVS com o seguinte.
$ cvs up -C ficheiro-a-desfazer
Salva a árvore de fonte local actualizada para o CVS com o seguinte.
$ cvs ci -m "Descreve alteração"
Crie e adicione o ficheiro "ficheiro-a-adicionar
" ao CVS
com o seguinte.
$ vi ficheiro-a-adicionar $ cvs add ficheiro-a-adicionar $ cvs ci -m "ficheiro-a-adicionar adicionado"
Funda a versão mais recente do CVS com o seguinte.
$ cvs up -d
Procure por linhas que comecem com "C filename
" as quais
indicam alterações em conflito.
Procura código não modificado em
".#nome-ficheiro.versão
".
Procura por "<<<<<<<
" e
">>>>>>>
" em ficheiros por
alterações em conflito.
Edite os ficheiros para corrigir os conflitos como necessário.
Adicione uma etiqueta de lançamento "Release-1
" com o
seguinte.
$ cvs ci -m "última submissão para Release-1" $ cvs tag Release-1
Continuar a editar.
Remova a etiqueta de lançamento "Release-1
" com o
seguinte.
$ cvs tag -d Release-1
Verifique as alterações no CVS com o seguinte.
$ cvs ci -m "última submissão real para Release-1"
Re-adicione a etiqueta de lançamento "Release-1
" para o
CABEÇALHO CVS actualizado de main com o seguinte.
$ cvs tag Release-1
Crie um branch com uma etiqueta autocolante de branch
"Release-initial-bugfixes
" a partir da versão original
apontada pela etiqueta "Release-initial
" e faça o check
out para o directório "~/path/to/old
" com o seguinte.
$ cvs rtag -b -r Release-initial Release-initial-bugfixes module1 $ cd ~/path/to $ cvs co -r Release-initial-bugfixes -d old module1 $ cd old
![]() |
Dica |
---|---|
Use " |
Trabalhe nesta árvore de fonte local tendo a etiqueta autocolante
"Release-initial-bugfixes
" a qual é baseada na versão
original.
Trabalhe neste branch por si … até que alguém se junte a este branch
"Release-initial-bugfixes
".
Sincronize com ficheiros modificados por outros neste branch enquanto cria novos directórios se necessário com o seguinte.
$ cvs up -d
Edite os ficheiros para corrigir os conflitos como necessário.
Verifique as alterações no CVS com o seguinte.
$ cvs ci -m "check feito para este branch"
Actualize a árvore local pelo CABEÇALHO do main enquanto remove a etiqueta
autocolante ("-A
") e sem a extensão de palavra chave
("-kk
") com o seguinte.
$ cvs up -d -kk -A
Actualize a árvore local (conteúdo = CABEÇALHO de main) ao fundir do branch
"Release-initial-bugfixes
" e sem a expansão palavra chave
com o seguinte.
$ cvs up -d -kk -j Release-initial-bugfixes
Corrigir conflitos com o editor.
Verifique as alterações no CVS com o seguinte.
$ cvs ci -m "Release-initial-bugfixes fundido"
Criar arquivo com o seguinte.
$ cd .. $ mv old old-module1-bugfixes $ tar -cvzf old-module1-bugfixes.tar.gz old-module1-bugfixes $ rm -rf old-module1-bugfixes
![]() |
Dica |
---|---|
O comando " |
![]() |
Dica |
---|---|
Você pode fazer checkout apenas a um sub directório de
" |
Tabela 10.18. Opções notáveis para comandos CVS (use como primeiro argumento(s) para o cvs(1))
opção | significado |
---|---|
-n
|
nadar em 'seco', nenhum efeito |
-t
|
mostra mensagens que mostram os passos da actividade do cvs |
Para obter os ficheiros mais recentes do CVS, use
"tomorrow
" com o seguinte.
$ cvs ex -D tomorrow nome-do-módulo
Adicione o alias de módulo "mx
" a um projecto de CVS
(servidor local) com o seguinte.
$ export CVSROOT=/srv/cvs/project $ cvs co CVSROOT/modules $ cd CVSROOT $ echo "mx -a module1" >>modules $ cvs ci -m "Agora mx é um alias para module1" $ cvs release -d .
Agora, você pode fazer check out ao "module1
" (alias:
"mx
") do CVS para o directório "new
"
com o seguinte.
$ cvs co -d new mx $ cd new
![]() |
Nota |
---|---|
De modo a executar o procedimento em cima, você precisa ter as permissões de ficheiro apropriadas. |
Quando você faz checkout a ficheiros de CVS, o seu bit de permissão de execução é retido.
Sempre que veja problemas com a permissão de execução num ficheiro a que fez
check out, ex. "nome-de-ficheiro
", mude as suas
permissões no repositório CVS correspondente com o seguinte para a corrigir.
# chmod ugo-x nome-de-ficheiro
Subversion é um sistema de controle de versão de geração-recente que substitui o antigo CVS. Tem a maioria das funcionalidades do CVS excepto as tags e branches.
Você precisa instalar os pacotes subversion
,
libapache2-svn
e subversion-tools
para
configurar um servidor Subversion.
Actualmente, o pacote subversion
não configura um
repositório, então é preciso configurar um manualmente. Uma possível
localização para um repositório é em "/srv/svn/project
".
Crie um directório com o seguinte.
# mkdir -p /srv/svn/project
Crie a base de dados do repositório com o seguinte.
# svnadmin create /srv/svn/project
Se você apenas aceder ao repositório Subversion via servidor Apache2, você apenas precisa de activar a escrita no repositório pelo servidor WWW com o seguinte.
# chown -R www-data:www-data /srv/svn/project
Adicione (ou des-comente) o seguinte em
"/etc/apache2/mods-available/dav_svn.conf
" para permitir
o acesso ao repositório via autenticação do utilizador.
<Location /project> DAV svn SVNPath /srv/svn/project AuthType Basic AuthName "Subversion repository" AuthUserFile /etc/subversion/passwd <LimitExcept GET PROPFIND OPTIONS REPORT> Require valid-user </LimitExcept> </Location>
Crie um ficheiro de autenticação de utilizador com o comando com o seguinte.
# htpasswd2 -c /etc/subversion/passwd algum_nome_de_utilizador
Reiniciar o Apache2
O seu novo repositório Subversion está acessível no URL
"http://localhost/project
" e
"http://exemplo.com/project
" a partir de
svn(1)
(assumindo que o URL do seu servidor web é
"http://exemplo.com/
").
O seguinte configura um repositório Subversion para acesso local pelo grupo,
ex. project
.
# chmod 2775 /srv/svn/project # chown -R root:src /srv/svn/project # chmod -R ug+rwX /srv/svn/project
O seu novo repositório Subversion está acessível ao grupo no URL
"file:///localhost/srv/svn/project
" ou
"file:///srv/svn/project
" a partir de
svn(1)
para os utilizadores locais que pertençam ao grupo
project
. Você tem de correr comandos, como o
svn
, svnserve
,
svnlook
, e svnadmin
sob
"umask 002
" para assegurar o acesso do grupo.
Um repositório Subversion acessível por grupo está no URL
"example.com:/srv/svn/project
" para SSH, você pode
aceder-lhe a partir de
svn(1)
no URL "svn+ssh://example.com:/srv/svn/project
".
Muitos projectos usam árvores de directórios semelhantes à seguinte para o Subversion para compensar a falta de branches e tags.
----- module1 | |-- branches | |-- tags | | |-- release-1.0 | | `-- release-2.0 | | | `-- trunk | |-- file1 | |-- file2 | `-- file3 | `-- module2
![]() |
Dica |
---|---|
Você tem de usar o comando " |
Crie uma nova localização de árvore fonte local em
"~/caminho/para/module1
" com o seguinte.
$ mkdir -p ~/caminho/para/module1; cd ~/caminho/para/module1
Povoa uma nova árvore fonte local sob
"~/caminho/para/module1
" como ficheiros.
Importe-o para Subversion com os seguintes parâmetros.
Module name: "module1
"
Subversion site URL: "file:///srv/svn/project
"
Subversion directory: "module1/trunk
"
Subversion tag: "module1/tags/Release-initial
"
$ cd ~/path/to/module1 $ svn import file:///srv/svn/project/module1/trunk -m "Start module1" $ svn cp file:///srv/svn/project/module1/trunk file:///srv/svn/project/module1/tags/Release-initial
Alternativamente, pelo seguinte.
$ svn import ~/path/to/module1 file:///srv/svn/project/module1/trunk -m "Start module1" $ svn cp file:///srv/svn/project/module1/trunk file:///srv/svn/project/module1/tags/Release-initial
![]() |
Dica |
---|---|
Você pode substituir URLs como o " |
Aqui está um exemplo do fluxo de trabalho típico usando o Subversion com o seu cliente nativo.
![]() |
Dica |
---|---|
Os comandos de cliente oferecidos pelo pacote |
Verifique todos os módulos disponíveis do projecto do Subversion apontado
pelo URL "file:///srv/svn/project
" com o seguinte.
$ svn list file:///srv/svn/project module1 module2 ...
Faz checkout a "module1/trunk
" para um directório
"module1
" com o seguinte.
$ cd ~/caminho/para $ svn co file:///srv/svn/project/module1/trunk module1 $ cd module1
Faça as alterações necessárias ao conteúdo.
Verifique alterações ao fazer "diff -u [repositório]
[local]
" equivalente ao seguinte.
$ svn diff
Você descobre que danificou o ficheiro
"ficheiro-a-desfazer
" severamente mas os outros ficheiros
estão bem.
Sobrescreve "ficheiro_a_desfazer
" com a cópia limpa do
Subversion com o seguinte.
$ svn revert ficheiro_a_desfazer
Salve a árvore de fonte local actualizada para o Subversion com o seguinte.
$ svn ci -m "Descreve alteração"
Crie e adicione o ficheiro "ficheiro_a_adicionar
" ao
Subversion com o seguinte.
$ vi ficheiro_a_adicionar $ svn add ficheiro_a_adicionar $ svn ci -m "Adicionado ficheiro_a_adicionar"
Funde a versão mais recente do Subversion com o seguinte.
$ svn up
Procure por linhas que comecem com "C filename
" as quais
indicam alterações em conflito.
Procura por código não modificado em, ex., "filename.r6
",
"filename.r9
", e "filename.mine
".
Procura por "<<<<<<<
" e
">>>>>>>
" em ficheiros por
alterações em conflito.
Edite os ficheiros para corrigir os conflitos como necessário.
Adicione uma etiqueta de lançamento "Release-1
" com o
seguinte.
$ svn ci -m "última submissão para Release-1" $ svn cp file:///srv/svn/project/module1/trunk file:///srv/svn/project/module1/tags/Release-1
Continuar a editar.
Remova a etiqueta de lançamento "Release-1
" com o
seguinte.
$ svn rm file:///srv/svn/project/module1/tags/Release-1
Verifique as alterações ao Subversion com o seguinte.
$ svn ci -m "última submissão real para Release-1"
Re-adicione a etiqueta de lançamento "Release-1
" a partir
de do CABEÇALHO do trunk Subversion actualizado com o seguinte.
$ svn cp file:///srv/svn/project/module1/trunk file:///srv/svn/project/module1/tags/Release-1
Crie um branch com o caminho
"module1/branches/Release-initial-bugfixes
" a partir da
versão original apontada pelo caminho
"module1/tags/Release-initial
" e faça check out a ele
para o directório "~/path/to/old
" com o seguinte.
$ svn cp file:///srv/svn/project/module1/tags/Release-initial file:///srv/svn/project/module1/branches/Release-initial-bugfixes $ cd ~/path/to $ svn co file:///srv/svn/project/module1/branches/Release-initial-bugfixes old $ cd old
![]() |
Dica |
---|---|
Use " |
Trabalhe nesta árvore de fonte local que aponta para o branch
"Release-initial-bugfixes
" o qual é baseado na versão
original.
Trabalhe neste branch por si … até que alguém se junte a este branch
"Release-initial-bugfixes
".
Sincronize com ficheiros modificados por outros neste branch com o seguinte.
$ svn up
Edite os ficheiros para corrigir os conflitos como necessário.
Verifique as alterações ao Subversion com o seguinte.
$ svn ci -m "check feito para este branch"
Actualize a árvore local com o CABEÇALHO do trunk com o seguinte.
$ svn switch file:///srv/svn/project/module1/trunk
Actualize a árvore local (conteúdo = CABEÇALHO do trunk) ao fundir a partir
do branch "Release-initial-bugfixes
" com o seguinte.
$ svn merge file:///srv/svn/project/module1/branches/Release-initial-bugfixes
Corrigir conflitos com o editor.
Verifique as alterações ao Subversion com o seguinte.
$ svn ci -m "merged Release-initial-bugfixes"
Criar arquivo com o seguinte.
$ cd .. $ mv old old-module1-bugfixes $ tar -cvzf old-module1-bugfixes.tar.gz old-module1-bugfixes $ rm -rf old-module1-bugfixes
![]() |
Dica |
---|---|
Você pode substituir URLs como o " |
![]() |
Dica |
---|---|
Você pode fazer checkout apenas a um sub directório do
" |
Tabela 10.19. Opções notáveis para os comandos do Subversion (use como primeiro argumento) para o svn(1))
opção | significado |
---|---|
--dry-run
|
nadar em 'seco', nenhum efeito |
-v
|
mostra mensagens detalhadas da actividade do svn |
O Git pode fazer tudo para gestão de código fonte tanto local como remoto. Isto significa que você pode gravar as alterações no código fonte sem precisar de ligação de rede ao repositório remoto.
Você pode desejar definir várias configurações globais em
"~/.gitconfig
" como o seu nome e endereço de mail usado
pelo Git com o seguinte.
$ git config --global user.name "Nome Apelido" $ git config --global user.email seu-nome@exemplo.com
Se você está muito acostumado aos comandos do CVS ou Subversion, pode desejar definir nomes alternativos a vários comandos com o seguinte.
$ git config --global alias.ci "commit -a" $ git config --global alias.co checkout
Você pode verificar a sua configuração global com o seguinte.
$ git config --global --list
Veja o seguinte.
manual: git(1)
(/usr/share/doc/git-doc/git.html
)
Manual do Utilizador do Git
(/usr/share/doc/git-doc/user-manual.html
)
Um tutorial de introdução ao
git (/usr/share/doc/git-doc/gittutorial.html
)
Um tutorial de introdução ao
git: parte dois
(/usr/share/doc/git-doc/gittutorial-2.html
)
Git do Dia-a-Dia com Cerca de
20 Comandos
(/usr/share/doc/git-doc/everyday.html
)
git para utilizadores do CVS
(/usr/share/doc/git-doc/gitcvs-migration.html
)
Isto também descreve como configurar um servidor tipo CVS e extrair dados antigos do CVS para o Git.
Outros recursos do git disponíveis na web
Magia do Git
(/usr/share/doc/gitmagic/html/index.html
)
Os comandos git-gui(1) e gitk(1) tornam a utilização do Git muito fácil.
![]() |
Atenção |
---|---|
Não use a string de etiqueta (tag) com espaços nela, mesmo que algumas
ferramentas como o
gitk(1)
o permitam. Pode estrangular outros comandos do |
Mesmo que o seu repositório de origem use um VCS diferente, pode ser boa ideia usar o git(1) para actividade local porque você pode gerir a sua cópia local da árvore fonte sem a ligação de rede ao repositório de origem. Aqui estão alguns pacotes e comandos usados com o git(1).
Tabela 10.20. Lista de pacotes e comandos relacionados com o git
comando | pacote | popcon | tamanho | descrição |
---|---|---|---|---|
N/D |
git-doc *
|
I:2 | 7865 | documentação oficial para o Git |
N/D |
gitmagic *
|
I:0.3 | 924 | "Magia do Git", guia fácil de compreender para o Git |
git(7) |
git
*
|
V:10, I:35 | 10625 | Git, o sistema de controlo de revisão distribuído, rápido e escalável |
gitk(1) |
gitk
*
|
V:0.9, I:5 | 1015 | explorador GUI de repositórios Git com histórico |
git-gui(1) |
git-gui *
|
V:0.2, I:3 | 1630 | GUI para Git (Nenhum histórico) |
git-svnimport(1) |
git-svn *
|
V:0.4, I:3 | 659 | importa os dados de Subversion para Git |
git-svn(1) |
git-svn *
|
V:0.4, I:3 | 659 | disponibiliza operação bi-direccional entre Subversion e Git |
git-cvsimport(1) |
git-cvs *
|
V:0.14, I:1.7 | 755 | importa os dados de CVS para Git |
git-cvsexportcommit(1) |
git-cvs *
|
V:0.14, I:1.7 | 755 | exporta uma submissão para um checkout do CVS a partir do Git |
git-cvsserver(1) |
git-cvs *
|
V:0.14, I:1.7 | 755 | emulador de servidor CVS para o Git |
git-send-email(1) |
git-email *
|
V:0.12, I:1.8 | 505 | envia uma colecção de patches como email a partir do Git |
stg(1) |
stgit
*
|
V:0.07, I:0.7 | 1864 | quilt no topo do git (Python) |
git-buildpackage(1) |
git-buildpackage *
|
V:0.2, I:1.1 | 1539 | automatiza o empacotamento Debian com o Git |
guilt(7) |
guilt
*
|
V:0.01, I:0.07 | 360 | quilt no topo do git (SH/AWK/SED/…) |
![]() |
Dica |
---|---|
Com o
git(1),
você trabalha num branch local com muitas submissões e usa algo como
" |
![]() |
Dica |
---|---|
Quando você deseja recuar para um directório de trabalho limpo sem perder o
estado actual do directório de trabalho, você pode usar o " |
Você pode fazer check out a um repositório Subversion em
"svn+ssh://svn.example.org/project/module/trunk
" para um
repositório Git local em "./dest
" e submeter de volta
para o repositório Subversion. Ex.:
$ git svn clone -s -rHEAD svn+ssh://svn.example.org/project dest $ cd dest ... faz as alterações $ git commit -a ... continua a trabalhar localmente com o git $ git svn dcommit
![]() |
Dica |
---|---|
O uso de " |
Você pode gravar manualmente o histórico cronológico da configuração usando
ferramentas do Git. Aqui está um exemplo simples
para você praticar a gravar os conteúdos de "/etc/apt/
".
$ cd /etc/apt/ $ sudo git init $ sudo chmod 700 .git $ sudo git add . $ sudo git commit -a
Cometer configuração com descrição
Fazer modificações nos ficheiros de configuração.
$ cd /etc/apt/ $ sudo git commit -a
Cometer a configuração com descrição e continuar com a sua vida.
$ cd /etc/apt/ $ sudo gitk --all
Você tem o histórico de configuração completo consigo.
![]() |
Nota |
---|---|
O
sudo(8)
é necessário para trabalhar com quaisquer permissões de ficheiros de dados
de configuração. Para os dados de configuração do utilizador, você pode
descartar o |
![]() |
Nota |
---|---|
O comando " |
![]() |
Dica |
---|---|
Para uma solução mais completa para gravação do histórico de configuração,
por favor procure o pacote |