# Instalando &debian-gnu; a partir de um sistema Unix/Linux

Esta seção explica como instalar o &debian-gnu; a partir de um sistema Unix ou Linux já existente, sem usar o sistema de instalação guiado por menus como explicado no resto deste manual. O HOWTO cross-install foi pedido por usuários que estavam migrando para o &debian-gnu; a partir do Red Hat, Mandriva e SUSE. É assumida nesta seção alguma familiaridade com a linha de comando e navegação no sistema de arquivos. O símbolo `$` significa um comando que será executado por um usuário atual do sistema, enquanto `#` se refere a um comando no chroot do &debian;.

Uma vez que tiver o novo sistema &debian; configurado para sua preferência, você poderá migrar os dados existentes de usuários (se existirem) para ele, e mantê-lo em pleno funcionamento. Isto é chamada instalação do &debian-gnu; sem interrupção. Este também é um excelente método para lidar com hardwares que não se comportam de forma amigável com vários tipos de inicialização ou mídias de instalação.

Como esse é, em sua grande maioria, um procedimento manual, tenha em mente que você mesmo terá que fazer várias configurações básicas do sistema, o que também demandará muito mais conhecimento do &debian; e do &arch-kernel; em geral do que a execução de uma instalação normal. Você não pode esperar que este procedimento resulte em um sistema idêntico ao de uma instalação normal. Você deverá ter em mente que este procedimento só dá os passos básicos para configurar um sistema. Passos adicionais de instalação e/ou configuração podem ser necessários.

## Iniciando

Com as ferramentas atuais de particionamento do *nix, reparticione o disco rígido como necessário, crie pelo menos um sistema de arquivos mais a partição swap. Você precisará por volta de &base-system-size;MB de espaço disponível para a instalação somente da console ou algo como &task-desktop-lxde-inst;MB se planeja instalar o X (mais se você pretende instalar ambientes desktop como GNOME ou KDE).

A seguir, crie um sistema de arquivos nas partições. Por exemplo, para criar um sistema de arquivos ext3 na partição `/dev/sda6` (esta é nossa partição raiz):

     # mke2fs -j /dev/sda6

Para criar ao invés deste um sistema de arquivos ext2, não utilize a opção `-j`.

Inicialize e ative a partição swap (substitua o número da partição pela partição que deseja usar para a &debian;):

     # mkswap /dev/sda5
     # sync
     # swapon /dev/sda5

Monte uma partição como `/mnt/debinst` (o ponto de montagem da instalação, que será o dispositivo raiz (`/`) de seu novo sistema). O ponto de montagem é de livre escolha e será referenciado mais adiante no texto.

     # mkdir /mnt/debinst
     # mount /dev/sda6 /mnt/debinst

Se você quer ter partes do seus sistemas de arquivos (e.g. /usr) montadas em partições separadas, você precisa criar e montar esses diretórios manualmente antes de proceder para o próximo estágio.

## Instalar o `debootstrap`

O utilitário usado pelo instalador &debian;, e reconhecido como o método oficial de instalar um sistema base &debian;, é o `debootstrap`. Ele utiliza o `wget` e o `ar`, mas depende somente do `/bin/sh` e de ferramentas básicas Unix/Linux

Esses utilitários incluem as principais ferramentas GNU (GNU core utilities) e comandos como o `sed`, `grep`, `tar` e o `gzip`.

. Instale o `wget` e o `ar` caso ele ainda não esteja instalado em seu sistema, então baixe e instale o `debootstrap`.

Ou poderá usar o seguinte procedimento para instalá-lo manualmente. Crie uma pasta de trabalho para extração do pacote .deb:

     # mkdir work
     # cd work

O binário `debootstrap` está localizado nos arquivos da &debian; (se assegure de selecionar o arquivo apropriado para sua arquitetura). Baixe o pacote .deb do `debootstrap` de pool, copie o pacote para o diretório de trabalho e extraia os seus arquivos. Você precisará ter privilégios de root para instalar estes arquivos.

    # ar -x debootstrap_0.X.X_all.deb
    # cd /
    # zcat /full-path-to-work/work/data.tar.gz | tar xv

## Executando o `debootstrap`

O `debootstrap`, ao ser executado, pode baixar os arquivos necessários diretamente de um repositório. Você poderá substituí-lo por qualquer espelho (mirror) de arquivos da &debian; ao invés de usar `&archive-mirror;/debian` no exemplo do comando abaixo, use preferivelmente um mirror mais perto de você em sua rede. A lista de mirrors estão disponíveis a partir de .

Se tiver uma versão do CD &releasename; da &debian-gnu; montado em `/cdrom`, poderá substituir por uma url file ao invés de usar http: `file:/cdrom/debian/`

Substitua um dos seguintes por `ARCH` no comando `debootstrap`: `amd64`, `arm64`, `armel`, `armhf`, `i386`, `mips`, `mipsel`, `powerpc`, `ppc64el`, or `s390x`.

     # /usr/sbin/debootstrap --arch ARCH &releasename; \
         /mnt/debinst http://ftp.us.debian.org/debian

## Configurando o Sistema Básico

Agora que você tem um sistema real da &debian; em seu disco, execute o comando `chroot` dentro dele:

     # LANG=C.UTF-8 chroot /mnt/debinst /bin/bash

Após executar o chroot você pode precisar configurar a definição do terminal para ser compatível com o sistema base &debian;, por exemplo:

    # export TERM=xterm-color

### Criar arquivos de dispositivo device files

Neste ponto, o `/dev/` contém somente arquivos de dispositivos básicos. Para os próximos passos da instalação, arquivos de dispositivos adicionais podem ser necessários. Há diferentes formas de lidar com isso e qual método você deverá usar depende do sistema hospedeiro que você está usando para a instalação, se você pretende ou não usar um kernel modular, e se você pretende usar arquivos de dispositivo dinâmicos (e.g. usando `udev`) ou estáticos para o novo sistema.

Algumas das opções disponíveis são:

- criar um conjunto padrão de arquivos de dispositivo estáticos usando

      # apt-get install makedev
      # mount none /proc -t proc
      # cd /dev
      # MAKEDEV generic

- manualmente, criar somente arquivos de dispositivo específicos usando `MAKEDEV`

- montar por bind o /dev do seu sistema hospedeiro sobre o /dev do sistema alvo; note que os scripts postinst de alguns pacotes podem tentar criar arquivos de dispositivo, por isso essa opção deverá ser usada com cuidado

### Montando as Partições

Você precisará criar o arquivo `/etc/fstab`.

     # editor /etc/fstab

Aqui está um exemplo de como poderá modificar seu arquivo:

    # /etc/fstab: arquivo contendo informações estáticas do sistema de arquivos
    #
    # sist arq.      ponto mont.   tipo    opções                   dump passo
    /dev/XXX         /             ext3    defaults                 0    1
    /dev/XXX         /boot         ext3    ro,nosuid,nodev          0    2

    /dev/XXX         none          swap    sw                       0    0
    proc             /proc         proc    defaults                 0    0

    /dev/fd0         /media/floppy auto    noauto,rw,sync,user,exec 0    0
    /dev/cdrom       /media/cdrom  iso9660 noauto,ro,user,exec      0    0

    /dev/XXX         /tmp          ext3    rw,nosuid,nodev          0    2
    /dev/XXX         /var          ext3    rw,nosuid,nodev          0    2
    /dev/XXX         /usr          ext3    rw,nodev                 0    2
    /dev/XXX         /home         ext3    rw,nosuid,nodev          0    2

Use o comando `mount -a` para montar todos os sistemas de arquivos que especificou no seu `/etc/fstab`, ou, para montar os sistemas de arquivos individualmente, use:

     # mount /caminho  # e.g.:  mount /usr

Sistemas &debian; atuais possuem pontos de montagem para mídias removíveis sob `/media`, mas mantém ligações simbólicas de compatibilidade em `/`. Crie-os conforme for necessário, por exemplo:

    # cd /media
    # mkdir cdrom0
    # ln -s cdrom0 cdrom
    # cd /
    # ln -s media/cdrom

Você poderá montar o sistema de arquivos proc múltiplas vezes e em localizações diversas, pois `/proc` tem esta flexibilidade. Se não usar o `mount -a`, tenha certeza de montar o proc antes de continuar:

     # mount -t proc proc /proc

O comando `ls /proc` deveria agora exibir um diretório não vazio. Se isto falhar, você pode ser capaz de montar o proc de fora do chroot:

    # mount -t proc proc /mnt/debinst/proc

### Configurando o Fuso Horário

Uma opção no arquivo `/etc/default/rcS` determina se o sistema interpretará o relógio do hardware como tendo sido configurado em UTC ou no horário local. O seguinte comando permite que você defina isto e escolha seu fuso horário.

    # editor /etc/default/rcS
    # dpkg-reconfigure tzdata

### Configurar a Rede

Para configurar a rede, edite os arquivos `/etc/network/interfaces`, `/etc/resolv.conf`, `/etc/hostname` e `/etc/hosts`.

     # editor /etc/network/interfaces

Existem alguns exemplos simples em `/usr/share/doc/ifupdown/examples`:

    ######################################################################
    # /etc/network/interfaces -- arquivo de configuração para o ifup(8),
    # ifdown(8)  Veja a página de manual interfaces(5) para informações
    # sobre estas opções e ver quais estão disponíveis
    ######################################################################

    # Nós sempre desejamos ter a interface loopback
    #
    auto lo
    iface lo inet loopback

    # Para usar o dhcp:
    #
    # auto eth0
    # iface eth0 inet dhcp

    # Um exemplo de configuração com IP estático: (o broadcast e gateway são opcionais)
    #
    # auto eth0
    # iface eth0 inet static
    #     address 192.168.0.42
    #     network 192.168.0.0
    #     netmask 255.255.255.0
    #     broadcast 192.168.0.255
    #     gateway 192.168.0.1

Entre com o servidor de nomes e diretivas de pesquisa no arquivo `/etc/resolv.conf`:

     # editor /etc/resolv.conf

Um exemplo simples `/etc/resolv.conf`:

    search hqdom.local
    nameserver 10.1.1.36
    nameserver 192.168.9.100

Entre com seu nome de host (2 a 63 caracteres):

     # echo DebianHostName > /etc/hostname

E um `/etc/hosts` básico com suporte a IPv6:

    127.0.0.1 localhost
    127.0.1.1 DebianHostName

    # The following lines are desirable for IPv6 capable hosts
    ::1     ip6-localhost ip6-loopback
    fe00::0 ip6-localnet
    ff00::0 ip6-mcastprefix
    ff02::1 ip6-allnodes
    ff02::2 ip6-allrouters
    ff02::3 ip6-allhosts

Se tiver várias placas de rede, você poderá organizar os nomes na ordem desejada no arquivo `/etc/modules`. Então durante a inicialização, a placa terá seu nome associado com o nome da interface (eth0, eth1, etc.) que deseja.

### Configurando o Apt

Debootstrap terá criado um `/etc/apt/sources.list` muito básico que permitirá que você instale pacotes adicionais. No entanto, você pode querer adicionar algumas fontes extra, por exemplo, para os códigos-fonte dos pacotes e atualizações de segurança:

    deb-src http://ftp.us.debian.org/debian &releasename; main

    deb http://security.debian.org/ &releasename;/updates main
    deb-src http://security.debian.org/ &releasename;/updates main

Tenha certeza de executar `aptitude update` após ter feito as alterações na lista de fontes.

### Configure Locales and Keyboard

Para configurar suas definições de locales para usar um idioma diferente do Inglês, instale o pacote com suporte a `locales` e configure-o. Atualmente, o uso de locales UTF-8 é recomendado.

     # aptitude install locales
     # dpkg-reconfigure locales

Para configurar o seu teclado (se for necessário):

    # aptitude install console-setup
    # dpkg-reconfigure keyboard-configuration

Note que o teclado não pode ser definido enquanto estiver dentro do chroot, mas será configurado na próxima reinicialização.

## Instalar um Kernel

Se deseja tornar o sistema inicializável, você precisará de um kernel do &arch-kernel; e um gerenciador de inicialização. Identifique os kernels pré-empacotados com:

    # apt-cache search &kernelpackage;

Se você pretende usar um kernel pré-empacotado, você pode querer criar o arquivo de configuração `/etc/kernel-img.conf` antes de fazê-lo. Aqui está um arquivo de exemplo:

    # Kernel image management overrides
    # See kernel-img.conf(5) for details
    do_symlinks = yes
    relative_links = yes
    do_bootloader = yes
    do_bootfloppy = no
    do_initrd = yes
    link_in_boot = no

Para informações detalhadas sobre este arquivo e várias opções, consulte a sua página de manual que estará disponível após a instalação do pacote `kernel-package`. Nós recomendados que você verifique quais os valores apropriados para o seu sistema.

Então, instale o pacote do kernel de sua escolhe usando o nome do pacote.

    # aptitude install &kernelpackage;-arch-etc

Se você não criou um `/etc/kernel-img.conf` antes da instalação do kernel pré-empacotado, você pode ser questionado durante a instalação sobre algumas perguntas que se referem ao arquivo.

## Configurando seu Gerenciador de Inicialização

Para tornar seu sistema &debian-gnu; inicializável, ajuste seu gerenciador de partida para carregar o kernel instalado com sua nova partição raiz. Note que o `debootstrap` não instala um gerenciador de partida, no entanto você pode usar `aptitude` dentro do seu chroot &debian; para fazê-lo.

Veja `info grub` ou `man lilo.conf` por instruções de como configurar um gerenciador de partida. Se estiver mantendo o sistema que usou para instalar a &debian;, simplesmente adicione uma entrada para a nova instalação da &debian; no seu arquivo `menu.lst` ou `lilo.conf`. Para o `lilo.conf` você também precisará copiá-los para o novo sistema e editá-lo lá. Após terminar a edição, execute o `lilo` (lembre-se de usar o `lilo.conf` relativo ao sistema que está sendo instalado).

Instalar e configurar o `grub` é tão fácil quanto:

    # aptitude install grub
    # grub-install /dev/sda
    # update-grub

O segundo comando irá instalar o `grub` (neste caso na MBR do `sda`). O último comando criará um arquivo `/boot/grub/menu.lst` são e funcional.

Note que isto assume que um arquivo de dispositivo `/dev/sda` foi criado. Há métodos alternativos para instalar o `grub` mas eles estão fora do escopo deste apêndice.

Aqui está um arquivo `/etc/lilo.conf` básico como um exemplo:

    boot=/dev/sda6
    root=/dev/sda6
    install=menu
    delay=20
    lba32
    image=/vmlinuz
    initrd=/initrd.img
    label=Debian

Dependendo de qual carregador de inicialização você selecionou, você agora pode fazer algumas mudanças adicionais em `/etc/kernel-img.conf`.

Para o carregador de inicialização `grub`, você poderia definir a opção `do_bootloader` como no. E, para automaticamente atualizar o seu `/boot/grub/menu.lst` na instalação ou remoção de kernels &debian;, adicione as seguintes linhas:

    postinst_hook = update-grub
    postrm_hook   = update-grub

Para o carregador de inicialização `lilo`, o valor de `do_bootloader` precisa ficar como yes.

Veja `man yaboot.conf` por instruções de como configurar seu gerenciador de partida. Se estiver mantendo o sistema que usou para instalar a &debian;, apenas adicione uma entrada no arquivo `yaboot.conf` Você também poderá copiá-lo para o novo sistema e editá-lo lá. Após terminar a edição, execute `ybin` (lembre-se de usar o `yaboot.conf` relativo ao sistema que está sendo instalado).

Aqui está um arquivo `/etc/yaboot.conf` básico como exemplo:

    boot=/dev/sda2
    device=hd:
    partition=6
    root=/dev/sda6
    magicboot=/usr/lib/yaboot/ofboot
    timeout=50
    image=/vmlinux
    label=Debian

Em algumas máquinas, pode ser necessária a utilização de `ide0:` ao invés de `hd:`.

## Toques finais

Como mencionado anteriormente, o sistema instalado é muito básico. Se você gostaria de fazer o sistema um pouco mais maduro, há um método fácil para instalar todos os pacotes com a prioridade padrão (standard):

    # tasksel install standard

É claro, você também pode simplesmente usar o `aptitude` para instalar os pacotes individualmente.

Após a instalação, um número grande de pacotes baixados estarão em `/var/cache/apt/archives/`. Você pode liberar algum espaço em disco executando:

    # aptitude clean