Bootcamp
Alunos: Brenddon Gontijo e Filipe Ribeiro
Introdução
[editar | editar código-fonte]Visão Geral
[editar | editar código-fonte]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 | editar código-fonte]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 | editar código-fonte]Escopo
[editar | editar código-fonte]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:
- Criação de uma máquina virtual para ambiente de desenvolvimento para a aplicação;
- Automatização da instalação das dependências do projeto via Chef e Shell Script;
- Geração de pacote para facilitar a implantação;
Ferramentas, Ambientes e Infra-Estrutura
[editar | editar código-fonte]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 | editar código-fonte]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 | editar código-fonte]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 | editar código-fonte]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 | editar código-fonte]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 | editar código-fonte]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 | editar código-fonte]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 | editar código-fonte]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 | editar código-fonte]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 | editar código-fonte]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 | editar código-fonte]Esse script é executado antes do pacote ser removido
#!/bin/bash
set -e
# stop django server
invoke-rc.d django stop
postrm
[editar | editar código-fonte]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 | editar código-fonte]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 | editar código-fonte]changelog
[editar | editar código-fonte]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 | editar código-fonte]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 | editar código-fonte]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