Wikiversidade

Bootcamp

Alunos: Brenddon Gontijo e Filipe Ribeiro

Introdução editar

Visão Geral editar

Bootcamp é uma rede social corporativa de open source construída com base na liguagem Python usando a Web Framework Django. O projeto tem três aplicações básicas:

  • Feed (um microblog no mesmo estilo do Twitter)
  • Publicação de Artigos (Um blog colaborativo)
  • Central de Perguntas e Respostas (Uma plataforma semelhante ao Stack Overflow)

Propósito editar

O presente documento tem por finalidade apresentar o plano e execução do gerenciamento de configuração e mudanças do projeto Bootcamp. No contexto atual, este projeto não possui um processo muito bem definido destinado ao uso de Gerência de Configuração de Software, com isso espera-se ao fim deste experimento promover uma melhoria no que tange ao desenvolvimento do mesmo, angariando assim possíveis novos colaboradores gerando melhorias no produto.

Definição do Projeto editar

Escopo editar

Visando que a aplicação Bootcamp possui seu código aberto (open source) e buscando uma maior evolução/manutenção do mesmo, um ambiente de desenvolvimento fácil de ser reproduzido e com ferramentas que auxiliem em sua gestão é de fundamental importância, para isto, os seguintes objetivos foram identificados:

  1. Criação de uma máquina virtual para ambiente de desenvolvimento para a aplicação;
  2. Automatização da instalação das dependências do projeto via Chef e Shell Script;
  3. Geração de pacote para facilitar a implantação;

Ferramentas, Ambientes e Infra-Estrutura editar

Shell Script: Interpretador de comandos usado em distribuições GNU/Linux

Chef: Ferramenta para automatização de infraestruturas.

Git: Sistema de controle de versão distribuído e de gerenciamento de códigos fonte

Github: Serviço de Web Hosting Compartilhado para projetos que usam o controle de versionamento Git

Vagrant: Criação e configuração de ambientes de desenvolvimento com base em máquinas virtuais

Cronograma editar

Semana Período Foco de Estudo Atividade Status
1 01 de Junho a 08 de Junho Planejamento Construir Plano de Gerenciamento de Configuração Pronto
2 09 de Junho a 15 de Junho Máquina Virtual Estudo de soluções e ferramentas a serem implantadas e construção da máquina virtual Pronto
3 16 de Junho a 21 de Junho Empacotamento e configuração da VM Construção do pacote e configuração utilizando Chef Pronto
3 22 de Junho Apresentação Entrega Final

Vagrant e Chef editar

Para realizar a instação do vagrant siga os seguintes passos:

# Atualizando pacotes
$ sudo apt-get update

# Intalando Git e Vim
$ sudo apt-get install git vim -y

# Instalando Vagrant e VirtualBox
$ sudo apt-get install virtualbox virtualbox-dkms vagrant -y
$ sudo vagrant plugin install vagrant-omnibus

Após instalado o Vagrant e VirtualBox crie um diretório que irá conter o ambiente da máquina virtual:

$ mkdir ubuntu-vm && cd ubuntu-vm/

$ vagrant init precise32

O comando vagrant init irá criar um diretório .vagrant/ e um arquivo Vagrantfile, modifique o arquivo Vagrantfile para que o mesmo fique desta forma:

# -*- mode: ruby -*-
# vi: set ft=ruby :

VAGRANTFILE_API_VERSION = "2"

Vagrant.configure(VAGRANTFILE_API_VERSION) do |config|
  config.vm.box = "precise32"
  config.vm.box_url = "http://files.vagrantup.com/precise32.box"

  config.vm.provider :virtualbox do |vb|
    vb.customize ["modifyvm", :id, "--memory", "2048"]
  end

  config.vm.network :forwarded_port, guest: 3000, host: 3000

  config.omnibus.chef_version = "12.10.24"

  config.vm.provision :chef_solo do |chef|
    chef.cookbooks_path = ["cookbooks"]

    chef.add_recipe "apt"
    chef.add_recipe "vim"
    chef.add_recipe "git"
    chef.add_recipe "build-essential"
    chef.add_recipe "python"
  end
end

Este Vagrantfile configura a máquina virtual para possuir 2048 mb de RAM, encaminhamento do tráfego gerado na porta 3000 da VM para porta 3000 da máquina hospedeira, instalação do Chef e de seus cookbooks.

O chef_solo será responsável por instalar todos os cookbooks, porém, é necessário que as mesmas estejam em um diretório chamado cookbooks, para isso crie o arquivo "cookbooks_script.sh" que irá criar este diretório e baixar os cookbooks necessários:

$ touch cookbooks_script.sh && chmod +x cookbooks_script.sh

$ vim cookbooks_script.sh

Edite o arquivo cookbooks_script.sh para ficar desta maneira:

#!/bin/bash
# Script to download all necessary cookbooks for Chef and run vagrant up.

mkdir cookbooks && cd cookbooks/

git clone https://github.com/chef-cookbooks/apt.git
git clone https://github.com/chef-cookbooks/build-essential.git
git clone https://github.com/chef-cookbooks/chef_handler.git
git clone https://github.com/chef-cookbooks/compat_resource.git
git clone https://github.com/chef-cookbooks/dmg.git
git clone https://github.com/chef-cookbooks/git.git
git clone https://github.com/chef-cookbooks/mingw.git
git clone https://github.com/chef-cookbooks/vim.git
git clone https://github.com/chef-cookbooks/windows.git
git clone https://github.com/chef-cookbooks/yum-epel.git
git clone https://github.com/chef-cookbooks/yum.git
git clone https://github.com/daptiv/seven_zip.git
git clone https://github.com/poise/python.git
git clone https://github.com/sethvargo/chef-sugar.git

cd .. && vagrant up

vagrant ssh -c "/vagrant/after_installation_script.sh"
vagrant ssh

Antes de executar este script crie outro script chamado "after_installation_script.sh", o qual será executado dentro da máquina virtual criada para realizar a instalação de algumas dependências importantes e o Bootcamp em si:

$ touch after_installation_script.sh && chmod +x after_installation_script.sh

$ vim after_installation_script.sh

Edite o arquivo after_installation_script.sh para ficar desta maneira:

#!/bin/bash
# Shell script to install final dependencies and Bootcamp inside Virtual Machine.

sudo apt-get install libjpeg-dev libpq-dev python-dev -y

git clone https://github.com/vitorfs/bootcamp.git

cd bootcamp/ && sudo pip install -U -r requirements.txt

touch .env
echo "DEBUG=True" >> .env
echo "SECRET_KEY=s3cr3t_key" >> .env
echo "DATABASE_URL=sqlite:////tmp/db.sqlite3vagrant" >> .env

python manage.py makemigrations
python manage.py migrate

Após criado os 2 scripts execute o cookbooks_script.sh:

$ ./cookbooks_script.sh

Após o script set executado você já estará dentro da máquina virtual, rode o Bootcamp para ver se tudo ocorreu de maneira certa:

$ cd bootcamp/

$ python manage.py runserver 0.0.0.0:3000

Para sair da máquina virtual aperte Ctrl + d ou digite no terminal o comando exit.

Para entrar na máquina virtual inicialize-a com o comando vagrant up e para acessá-la utilize vagrant ssh.

Empacotamento Debian editar

Para realizar o empacotamento da aplicação siga os seguintes passos:

O primeiro passo é criar uma pasta debian para os futuros pacotes que serão gerados

$ mkdir .debian

Agora é a hora de alocar nosso projeto dentro de uma subpasta (assumindo que o mesmo já tenha sido clonado)

$ mkdir -p ./debian/usr/share
$ cp -r bootcamp/ ./debian/usr/share/

Terminando essa parte de estruturação de pastas, também se faz necessário a criação de uma subpasta DEBIAN que será responsável por gerir os arquivos fundamentais que estruturam o pacote.

$ mkdir ./debian/DEBIAN

Arquivos DEBIAN editar

Como dito anteriormente, essa pasta será responsável por gerir os principais arquivos estruturais do pacote. Esses arquivos são:

  • control
  • config
  • conffiles
  • templates
  • postinst
  • postrm
  • preinst
  • prerm

control editar

Este arquivo é o mais importante pois é dele que vem atributos básicos do pacote como as principais informações do pacote juntamente com algumas dependências. No nosso caso esse é o nosso arquivo

Package: bootcamp
Version: 0.1-1
Section: devel
Priority: optional
Architecture: all
Depends: python, python-django, python-flup, debconf, lighttpd
Maintainer: Filipe Ribeiro <filiperibeirom7@gmail.com>
Description: Enterprise Social Network
  Botcamp is an open source enterprise social network built with Python using the Django Web Framework.
  The project has three basic apps:Feed (A Twitter-like microblog), Articles (A collaborative blog),
  Question & Answers (A Stack Overflow-like platform).

config editar

Config é um script responsável por fazer perguntas para o usuário antes que o pacote seja instalado. Nesse caso, vamos fazer uma pergunta simples: "Qual seu nome?"

#!/bin/sh -e

# Source debconf library.
. /usr/share/debconf/confmodule
 
# server type?
db_input critical bootcamp/username || true
db_go

templates editar

Este é o lugar onde é definida a string de pergunta falada na seção acima

Template: bootcamp/username
Type: string
Description: Username:
This package requires your full name.

preinst editar

Como o nome sugere esse script é executado antes da instalação do pacote.

#!/bin/bash
set -e
 
# stop django server
if [ -f /etc/init.d/django ]
then
  invoke-rc.d django stop
fi

postinst editar

Ao contrário do preinst, esse arquivo é executado depois que é feito o desempacotamento

#!/bin/sh
set -e

# Source debconf library.
. /usr/share/debconf/confmodule

db_get bootcamp/username
username="$RET"
# do what you want with this username

# register django
update-rc.d django defaults 90 >/dev/null
# start django
invoke-rc.d django start
 
db_stop

prerm editar

Esse script é executado antes do pacote ser removido 

#!/bin/bash
set -e
 
# stop django server
invoke-rc.d django stop

postrm editar

Esse script é executado depois do pacote ser removido 

#!/bin/bash
set -e

if [ "$1" = "purge" -a -e /usr/share/debconf/confmodule ]; then
    # Source debconf library.
    . /usr/share/debconf/confmodule
    # Remove my changes to the db.
    db_purge
fi

if [ "$1" = "remove" ]; then
    # Source debconf library.
    . /usr/share/debconf/confmodule

# remove Django start script
update-rc.d -f django remove

# Remove my changes to the db.

db_purge
fi

conffiles editar

Conffiles contêm configurações mais genéricas e ficam localizadas na pasta /etc (ainda dentro da nossa pasta .debian). Lá são alocados os scripts de iniciação e o arquivo de configuração lighttpd, Caso a pasta ainda não possuir uma subpasta /etc/, é muito importante que ela seja criada agora

$ mkdir .debian/etc/init.d/
$ mkdir .debian/etc/lighttpd/

A subpasta lighttpd possuíra o arquivo lighttpd.conf que será o responsável por gerenciar a configuração do web server, que fará a aplicação ficar disponível para testes no browser. O script desse arquivo se encontra logo abaixo

fastcgi.server = (
  "/bootcamp.fcgi" => (
    "main" => (
      # Use host / port instead of socket for TCP fastcgi
      "host" => "127.0.0.1",
      "port" => 3033,
      "check-local" => "disable",
  ))
)

A subpasta init.d possuíra o arquivo django que será o responsável por gerenciar o start e o stop da aplicação. O script desse arquivo se encontra logo abaixo

fastcgi.server = (
  "/bootcamp.fcgi" => (
    "main" => (
      # Use host / port instead of socket for TCP fastcgi
      "host" => "127.0.0.1",
      "port" => 3033,
      "check-local" => "disable",
  ))
)

vagrant@debian-jessie:~$ cat .debian/etc/init.d/django 
#! /bin/sh
### BEGIN INIT INFO
# Provides:          FastCGI servers for Django
# Required-Start:    networking
# Required-Stop:     networking
# Default-Start:     2 3 4 5
# Default-Stop:      0 1 6
# Short-Description: Django FastCGI
#
 
DJANGO_SITE="bootcamp"
SITE_PATH=/var/www
RUNFILES_PATH=$SITES_PATH/tmp
HOST=127.0.0.1
PORT_START=3033
RUN_AS=www-data
 
set -e
 
PATH=/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin
DESC="Django FastCGI"
NAME=$0
SCRIPTNAME=/etc/init.d/$NAME
 
#       Function that starts the daemon/service.
#
d_start()
{
    # Starting all Django FastCGI processes
    echo -n ", $DJANGO_SITE"
    if [ -f $RUNFILES_PATH/$DJANGO_SITE.pid ]; then
        echo -n " already running"
    else
       start-stop-daemon --start --quiet \
                       --pidfile $RUNFILES_PATH/$DJANGO_SITE.pid \
                       --chuid $RUN_AS --exec /usr/bin/env -- python \
                       $SITE_PATH/$DJANGO_SITE/manage.py runfcgi \
                       host=$HOST port=$PORT \
                       pidfile=$RUNFILES_PATH/$DJANGO_SITE.pid
    fi
}
 
#
#       Function that stops the daemon/service.
#
d_stop() {
    # Killing all Django FastCGI processes running
    echo -n ", $DJANGO_SITE"
    start-stop-daemon --stop --quiet --pidfile $RUNFILES_PATH/$SITE.pid \
                          || echo -n " not running"
    if [ -f $RUNFILES_PATH/$DJANGO_SITE.pid ]; then
        rm $RUNFILES_PATH/$DJANGO_SITE.pid
    fi
}
 
ACTION="$1"
case "$ACTION" in
    start)
        echo -n "Starting $DESC: $NAME"
        d_start
        echo "."
        ;;
 
    stop)
        echo -n "Stopping $DESC: $NAME"
        d_stop
        echo "."
        ;;
 
    restart|force-reload)
        echo -n "Restarting $DESC: $NAME"
        d_stop
        sleep 1
        d_start
        echo "."
        ;;
 
    *)
        echo "Usage: $NAME {start|stop|restart|force-reload}" >&2
        exit 3
        ;;
esac
 
exit 0

Arquivos changelog, changelog.Debian e copyright editar

changelog editar 

bootcamp (0.1-1) unstable; urgency=low
  * Initial release.
    + Initial package
 
 -- Filipe Ribeiro <filiperibeirom7@gmail.com>  Wed, 29 June 2016 00:00:00 +0000

changelog e changelog.Debian são arquivos diferentes mas nesse caso, o conteúdo é o mesmo.

copyright editar 

Bootcamp
 
Copyright: 
 
2016-06-29
 
The home page of bootcamp is at:
http://trybootcamp.vitorfs.com/
 
Copyright  2010

Agora precisamos alocar esses arquivos nos seus devidos endereços, além de comprimir alguns arquivos. Os devidos procedimentos se encontram logo abaixo.

$ mkdir -p ./debian/usr/share/doc/bootcamp

$ cp changelog changelog.Debian copyright ./debian/usr/share/doc/bootcamp/

$ gzip --best ./debian/usr/share/doc/bootcamp/changelog

$ gzip --best ./debian/usr/share/doc/bootcamp/changelog.Debian

Construindo o Pacote editar

Agora é a hora da verdade onde o pacote começa a ganhar uma cara. A primeira coisa que se deve fazer é settar as permisões de alguns arquivos

$ chmod 755 postinst  postrm  preinst  prerm

Se recebe essa flag 755 pois se espera atribuir permissão de leitura, escrita e execução para o dono do arquivo (7), leitura e execução para usuários do mesmo grupo (5) e também para outros usuários (5). Com isso feito, para compilar o pacote os seguintes passos devem ser executados: 

$ fakeroot dpkg-deb --build debian

$ mv debian.deb bootcamp_0.1-1_all.deb

$ lintian bootcamp_0.1-1_all.deb

Se tudo tiver ocorrido bem, para instalar o pacote deve ser usado o comando

$ sudo dpkg -i bootcamp_0.1-1_all.deb
Obtida de "https://pt.wikiversity.org/w/index.php?title=Bootcamp&oldid=89901"