path: root/docs/bootstrap.md

# Bootstrap de uma configuração completa

Este documento tem como objetivo descrever o **processo de bootstrap** de uma
configuração completa de um servidor utilizando o [Padrão Saravá](/). O
*processo de bootstrap* pode ser compreendido como "o processo de coordenar
diversos processos interdepententes de forma que seja atingida uma configuração
sistêmica estável".

Para este processo, utilizaremos as seguintes ferramentas:

* [Debian GNU/Linux 6.0](http://www.debian.org/releases/squeeze/).
* [Linux-VServer](http://linux-vserver.org/) ([pacote do debian](http://packages.debian.org/squeeze/linux-image-2.6-vserver-686)).
* [Git](http://git-scm.com/) e [gitosis](http://swik.net/gitosis).
* [puppet-bootstrap](http://git.sarava.org/?p=puppet-bootstrap.git;a=summary).
* [hydra](http://git.sarava.org/?p=hydra.git;a=summary).

Os seguintes estágios fazem parte de uma instalação padrão completa:

## Instalação do sistema padrão na máquina hospedeira

Documentação [aqui](install.md).

## Configuração da máquina hospedeira

Configure algumas variáveis de ambiente:

    export domain="projeto.org"
    export hostname=`hostname | sed -e s/\\\\..*$//`
    export puppet_bootstrap_dir=/var/tmp/puppet-bootstrap
    export PUPPETLIB=${puppet_bootstrap_dir}/modules

Configure o arquivo `/etc/hosts` (a ordem dos hostnames influencia nos resultados do `facter`):

    cat > /etc/hosts <<EOF
    127.0.0.1 ${hostname}.${domain} ${hostname}
    127.0.0.1 localhost
    EOF

Instale o git e o puppet e clone o repositório `puppet-bootstrap`:

    apt-get -y install git-core puppet wipe
    git clone git://git.sarava.org/puppet-bootstrap ${puppet_bootstrap_dir}

Altere o arquivo `${puppet_bootstrap_dir}/manifests/config.pp` de acordo com suas necessidades.

Prepare o servidor para a utilização do puppet.

    puppet apply -d -v ${puppet_bootstrap_dir}/manifests/stage0.pp

Crie um vserver para abrigar o nó administrativo:

    puppet apply -d -v ${puppet_bootstrap_dir}/manifests/host-stage1.pp

Anote a fingerprint da chave ssh do vserver:

    vserver ${hostname}-master exec ssh-keygen -l -f /etc/ssh/ssh_host_rsa_key.pub

## Configuração do nó administrativo

A partir deste momento, vamos trabalhar apenas no nó administrativo recém criado.

Copie o `puppet-bootstrap` e a configuração padrão para o vserver e limpe os rastros:

    echo LANG=C > /var/vservers/${hostname}-master/etc/default/locale
    cp -r ${puppet_bootstrap_dir} \
      /var/vservers/${hostname}-master/${puppet_bootstrap_dir}
    cp -r /usr/local/puppet \
      /var/vservers/${hostname}-master/usr/local/puppet
    wipe -rcfq -S r -R /dev/urandom ${puppet_bootstrap_dir} /usr/local/puppet

Acesse o vserver e instale algumas ferramentas:

    vserver ${hostname}-master enter
    apt-get update
    apt-get -y upgrade
    apt-get -y install git puppet puppetmaster wipe

Configure o hostname e domínio do nó administrativo:

    cat > /etc/hosts <<EOF
    127.0.0.1 ${hostname}-master.${domain} ${hostname}
    127.0.0.1 localhost
    EOF

Prepare o vserver para a utilização do puppet.

    puppet apply -d -v ${puppet_bootstrap_dir}/manifests/stage0.pp
    puppet apply -d -v ${puppet_bootstrap_dir}/manifests/admin-stage1.pp

## Criação de repositórios padrão

Dê acesso ao repositório administrativo do gitosis a um usuário:

    sudo -H -u gitosis gitosis-init < FILENAME.pub

Clone o repositório administrativo do gitosis remotamente:

    git clone ssh://gitosis@servidor.${domain}:2202/gitosis-admin

Altere o arquivo `gitosis-admin/gitosis.conf` do repositório clonado e crie um
repositório para a configuração do puppet e um repositório para suas chaves
criptográficas:

    [gitosis]
    daemon      = no
    gitweb      = no
    public_http = no

    [group admin]
    writable = gitosis-admin puppet keyring
    members = usuario@maquina

Empurre as mudanças para o servidor:

    git commit -a -m "Adicionando repositórios para puppet e keyring"
    git push origin master

Para adicionar um novo usuário ao gitosis, basta adicionar as chaves públicas
ssh ao diretório `gitosis-admin/keydir/` com um nome de arquivo do tipo
`usuario@maquina.pub`.

## Configuração do repositório puppet

Altere as configurações padrão do puppet em `/usr/local/puppet/default-conf` de
acordo com suas necessidades e incialize os repositórios em `/etc/puppet` e
`/var/git/repositories/puppet`):

    /etc/init.d/puppetmaster stop
    rm -rf /etc/puppet && mkdir /etc/puppet
    cd /etc/puppet
    cp -r /usr/local/puppet/default-conf/* .
    wipe -rcfq -S r -R /usr/local/puppet
    git init
    git add *
    puppet-bootstrap add-submodules /etc/puppet
    git commit -m "Initial config."
    git clone --bare /etc/puppet/ /var/git/repositories/puppet.git
    chown -R gitosis:gitosis /var/git/repositories/puppet.git

Agora já podemos clonar o repositório de configurações do puppet remotamente:

    git clone ssh://gitosis@${hotname}.${domain}:2202/puppet.git

## Configuração da hydra

Esta parte da instalação gera chaves criptográficas e portanto deve ocorrer em
uma máquina com um nível de segurança significativo (criptografia de disco,
bootless, etc).

Instale `hydra` e `keyringer`:

    sudo apt-get -y install git-core
    # hydra
    sudo git clone git://git.sarava.org/hydra /usr/local/hydra
    sudo ln -sf /usr/local/hydra/hydra /usr/local/sbin/hydra
    sudo ln -sf /usr/local/hydra/hydra /usr/local/sbin/hydractl
    # keyringer
    sudo git clone git://git.sarava.org/keyringer /usr/local/keyringer
    sudo ln -sf /usr/local/keyringer/keyringer /usr/local/bin/keyringer

Tenha certeza que possui em seu chaveiro gpg as chaves dos usuários que irão
acessar o repositório de chaves. Crie um keyring para o projeto clonando o
repositório configurado:

    keyringer projeto init ~/projeto/keyring
    cd ~/projeto/keyring
    git init
    git remote add origin ssh://gitosis@servidor.${domain}:2202/keyring.git
    git add *
    git commit -m "initial commit"
    git push origin master

Clone o repositório de configuração do puppet e registre uma nova hydra:

    puppet_dir=~/projeto/puppet
    git clone git://gitosis@servidor.${domain}:2202/puppet $puppet_dir
    hydra projeto register $puppet_dir

Gere novas chaves para os nós configurados e as envie para os nós:

    hydra projeto newkeys
    hydra projeto import servidor.pub


## Partida do puppetmaster

    /etc/init.d/puppetmaster start

## Configuração de backups

1. Backup local criptografado:
    1. Criação de chaves GPG.
    2. Configuração do backup local.
2. Backup remoto:
    1. Criação de chaves SSH para armazenamento remoto de backup.
    2. Configuração do backup remoto.

## Criação de outros vservers/nós

* Nó de armazenamento ("storage") para agrupamento de backups.
* Proxy.
* Web.
* Test.

## Pedaços de código úteis para o bootstrap

### Configuração de submódulos padrão

    apt-get -y install puppetmaster puppet git-core openssh-server
    cd /etc/puppet
    mkdir modules
    git init
    git add .

    repos="`lynx -dump http://git.sarava.org/?a=project_index | awk '{ print $1 }' | grep ^puppet-`"
    for repo in $repos; do
      module="`basename $repo .git | sed -e s/^puppet-//`"
      if [ ! -d "modules/$module" ]; then
        git submodule add git://git.sarava.org/puppet-$module.git modules/$module
      fi
    done

No caso de bootstrap para um novo projeto, substitua as referências de `git.sarava.org` para `git.projeto.org`.

### Configurando referências remotas em massa

    # Configuracao
    origin="sarava.org"
    remotes="sarava.org:${port}"
    repos="`lynx -dump http://git.$origin/?a=project_index | awk '{ print $1 }' | grep ^puppet-`"

    # Adicionando referencias
    for repo in $repos; do
      module="`basename $repo .git | sed -e s/^puppet-//`"
      if [ -d "puppet-$module" ]; then
        cd puppet-$module
        for remote in $remotes; do
          ref="`echo $remote   | cut -d . -f 1`"
          domain="`echo remote | cut -d : -f 1`"
          port="`echo remote   | cut -d : -f 2`"
          git remote add $ref ssh://gitosis@git.$domain:$port/puppet-$module.git
          git push $ref master
        done
        cd ..
      fi
    done

### Mudando referências em submódulos

    # Configuracao
    origin="sarava.org"
    dest="exemplo.org"

    cd puppet
    sed -i -e "s/git.$origin/git.$dest/" .gitmodules
    cd modules
    for module in `ls`; do
      cd $module
      git remote rm origin
      git remote add origin git://git.$dest/puppet-$module.git
      git config branch.master.remote origin
      git config branch.master.merge refs/heads/master
      cd ..
    done

### Exemplo de criação em massa de módulos

    # Configuracao
    origin="sarava.org"
    remotes="sarava.org:${port}"

    mkdir puppet-{ikiwiki,moin,mysql,trac}/manifests -p
    touch puppet-{ikiwiki,moin,mysql,trac}/manifests/init.pp
    for module in ikiwiki moin mysql trac; do
      cd puppet-$module
      cp ../puppet-git/LICENSE .
      git init
      git add .
      git commit -a -m "Initial import"
      for remote in $remotes; do
        ref="`echo $remote   | cut -d . -f 1`"
        domain="`echo remote | cut -d : f 1`"
        port="`echo remote   | cut -d : f 2`"
        git remote add $ref ssh://gitosis@git.$domain:$port/puppet-$module.git
        git push $ref master
      done
      cd ..
    done