#JETPACK

##Overview O Jetpack são módulos baseados no Fabric. Vale a pena dar uma olhada para entender para que serve o Fabric. A idéia por trás disso é ter uma ferramenta que nos ajuda com as seguintes funções principais:

• Setup do Servidor, Aplicação e Banco de dados
• Interface para gerenciamento do servidor
• Interface para gerenciamento de configurações
• Deploy automatizado

##Disclaimer Antes de começar a explicar um pouco mais já aviso que como o Fabric é apenas uma camada de abstração, é preciso algum conhecimento sobre Nginx, Bash, Postgresql/MySQL, Ubuntu para enteder a fundo como os setups são feitos.

##Estrutura de arquivos O Jetpack tem a seguinte árvore de arquivos:

fabfile.py
├── host
│   ├── jobs.cron
│   ├── nginx.conf
│   ├── nginx.vhost
│   ├── rsyslog.conf
│   └── uwsgi.conf
├── jetpack
│   ├── __init__.py
│   ├── config.py
│   ├── db
│   │   ├── __init__.py
│   │   ├── mysql.py
│   │   └── pgsql.py
│   ├── deploy.py
│   ├── django.py
│   ├── helpers.py
│   ├── logs.py
│   ├── pg_backups.py
│   └── setup
│       ├── __init__.py
│       └── scripts
│           ├── mysql.sh
│           ├── pg_hba.conf
│           ├── postfix.sh
│           ├── postgresql.sh
│           ├── server_setup.sh
│           └── watchdog.sh

Como vocês podem ver existem diversos scripts Bash que fazem a configuração do Servidor e Banco de dados. Aconselho a ler eles para ter uma idéia do que temos instalado nos servidores. Se em algum momento cecessitarmos instalar uma nova depência do Ubuntu no projeto você deve fazer isso direto lá e depois atualizar o script server_setup.sh com isso. Além disso, também existe um diretório host onde ficam as configurações de cronjobs, wsgi e Nginx

##Módulos principais Cada outro arquivo .py é responsável por determinada interface com o servidor:

• config.py: Interface de configuração da app. Aqui nós adicionamos, alteramos e apagamos as configurações que vão ser usadas no settings.ini no servidor.
• db/pgsql.py edb/mysql.py: Eles fazem as configurações do banco de dados, como criação de novos usuários, bancos, backup, etc.
• deploy.py: Interface para fazer o deploy.
• django.py: Interface para interagir com os comandos do Django, como o manage.py.
• logs.py: Interface para ver os logs do sistema, aplicação e nginx.
• helpers.py: Alguns helpers auxilares aos outros módulos.
• pg_backups.py: Algumas ferramentas para gerenciar backup do banco no AWS S3.
• setup: Aqui ficam os scripts e ferramentas que fazem o setup inicial do servidor e aplicação.

##Configuração de uma nova VPS

Antes de começar a configurar a VPS é preciso criar um novo arquivo fabfile.py onde vamos criar uma task que terá a inciailização de um novo projeto:

# coding: utf-8
from fabric.api import task, env
from unipath import Path
from jetpack.helpers import Project

# Exposes other functionalities
from jetpack import setup, deploy, db, config, django, logs, pg_backups


# Always run fabric from the repository root dir.
Path(__file__).parent.chdir()

@task
def production():
    env.PROJECT = Project(
        project='{{ project_name Ex:my_blog }}',
        instance='{{ instance Ex: production }}',
        package='{{ where settings.py is }}'
    )
    env.hosts = ['{{ server_ip ou host_name }}']
    env.user = env.PROJECT.user

É muito importante conhecer melhor a classe Project, pois nela que ficam as configurações da sua aplicação.

Feito isso podemos começar a usar o fabric e os comandos do Jetpack. Em geral todos os comandos tem a seguinte estrutura: fab {{servidor}} {{comando}}. Usamos assim porque os comandos sempre precisam saber os dados sobre o servidor que vão acessar.

1- fab production setup.server: Esse comando instala as principais dependências na VPS, instala o Banco de dados que você escolheu e pode criar um superuser também, é aconselhavel, já que a partir de agora não vamos mais ter acesso de root a VPS. 2- fab production setup.application: Configura a estrutura para receber a aplicação. Vou explicar essa estrutura mais tarde 3- fab production db.pgsql.create: Configura um novo banco de dados usando o nome da aplicação e o usuário da aplicação. Isso pode ser customizado 4 - Configurar o host/ngnix.conf e jobs.cron e se quiser, customizar o uwsgi.conf

Com isso você já pode fazer seu primeiro deploy! fab production deploy:HEAD ou caso esteja usando tags: fab production deploy:1.0

##Estrutura do projeto no servidor

Se você fizer SSH em sua VPS vai poder ver a seguinte estrutura

/
├── home
│   ├── {{project_instance}} Ex: my_blog_production
│   │   ├── {{project_instance}} Ex: my_blog_production
│   │   │   ├── releases: Aqui ficam todas as releases, que são criadas cada vez que rodamos o deploy
│   │   │   │   ├── current: Release atual. É um link simbólico para a última release criada.
│   │   │   │   ├── 2015-10-28-15h50m29s: Release feita nessa data/hora.
│   │   │   ├── share: Aqui ficam as configurações que são compartilhadas entre as releases
│   │   │   ├── tmp: Arquivos temporários.

Isso é o básico do Jetpack, o código é bem simples e vale muito apena estudar todos os módulos para aprender como cada coisa funciona e quais comandos podemos usar. É muito importante sempre criar novos módulos e comandos no Jetpack para novas ações que são feitas sempre no servidor, dessa forma é mais fácil executar tarefas repetitivas e muito mais seguro.

##Estrutura de usuários

O Jetpack sempre cria um usuário com o nome do projeto+instância que tem as permissões necessárias para fazer o deploy e gerenciar tarefas referentes a aplicação, como por exemplo 'my_blog_production'. A sua chave pública já vai estar no allowed_keys desse usúario, mas se mais pessoas forem fazer o deploy é preciso adiciona-los usando: fab production setup.addkey:path/to/id_rsa.pub