LabExposed

BSD, Linux e software livre em geral.

Jail Rápido E Fácil No FreeBSD (Atualizado)

| Comments

Neste artigo “jogo rápido”, irei mostrar os comandos necessários para criar uma Jail no FreeBSD 12.1 usando os binários de instalação do FreeBSD. Ele é um texto ressucitado de post meu bem antigo, que esta ainda disponivel aqui

Para isso, vamos preparar o ambiente com o download do arquivo “base” a partir de um FTP, como no exemplo abaixo:

Você também pode usar o arquivo encontrado no cd de instalação

1
2
3
mkdir /jails/jail-dev
cd /jails/jail-dev
fetch -q -o - ftp://ftp.fr.freebsd.org/pub/FreeBSD/releases/amd64/amd64/12.1-RELEASE/base.txz | tar --unlink -xpJvf -

Se tiver ZFS, melhor ainda, crie um volume por exemplo com o comando abaixo:

1
2
zfs create -o compression=lz4 -o mountpoint=/jails zroot/jails
mkdir /jails/jail-dev

Configure alguns parâmetros na jail através de chroot na jail:

1
2
3
4
5
6
7
8
9
10
11
12
chroot /jails/jail-dev /bin/csh
# configure senha de root
passwd
# adicione um usuario
pw add user admin -m -s /bin/csh -G wheel
passwd admin
# configure o rc.conf
echo 'rpcbind_enable="NO"' >> /etc/rc.conf
echo 'network_interfaces=""' >> /etc/rc.conf
# crie um fstab vazio para evitar mensagens de erro
touch /etc/fstab
exit

Pronto, a Jail já esta funcional.

Configure-a conforme o exemplo abaixo no arquivo /etc/rc.conf:

1
2
3
4
5
6
7
8
9
jail_enable="YES"
jail_list="jaildev"
jail_jaildev_rootdir="/jails/jail-dev"
jail_jaildev_hostname="jail-dev.mundounix.com.br"
jail_jaildev_interface="bge0"
jail_jaildev_ip="192.168.83.100"
jail_jaildev_exec_start="/bin/sh /etc/rc"
jail_jaildev_exec_stop="/bin/sh /etc/rc.shutdown"
jail_jaildev_devfs_enable="YES"

Dai, é inicia-la com o comando:

1
/etc/rc.d/jail start jaildev

E divirta-se !

Instalando OpenBSD Em Um Cloud Linux

| Comments

Tutorial de instalação do OpenBSD 6.5 em um cloud com Linux

É muito simples, basta ter instalado no cloud um Linux com grub2 e você também precisa ter acesso ao terminal dele, ao menos para gerenciar o boot da VM/Cloud. Com isso, vamos fazer o grub carregar na memória uma imagem do OpenBSD na RAM do cloud, de forma que podemos ter o disco disponivel para formatação, a instalação dos binários é pela rede.

Vamos ao exemplo prático, o que temos?

Um cloud na CloudAtCost [1]
Instalação do Ubuntu 14.4

Faça a instalação do cloud com ubuntu (ou outro linux com grub2), feita a instalação, veja se ele configurou alguma partição sem lvm (normalmente o /boot, como no exemplo abaixo)

Faça o download do arquivo bsd.rd no repositorio do OpenBSD e mova para a raiz de montagem da partição sem lvm:

1
2
wget http://ftp.openbsd.org/pub/OpenBSD/6.5/amd64/bsd.rd
mv bsd.rd /boot/ 

Feito isso, adicione a entrada abaixo no arquivo /etc/grub.d/40_custom

1
2
3
4
menuentry "Install OpenBSD from RAM disk" {  
    set root=(hd0,1)
    kopenbsd /bsd.rd
}

É recomendável também que você aumente o tempo de timeout do grub no arquivo /etc/default/grub para que você possa escolher a opção de carregar o openbsd na memoria.

Agora, gere uma nova configuração do grub com o comando abaixo:

1
update-grub

Reinicie o cloud

1
reboot

E pronto !! na hora do boot, no menu do grub, escolha a opção “Install OpenBSD” e faça a instalação dele !

[1] http://www.cloudatcost.com/

Fonte essencial para isso: http://openbsd-archive.7691.n7.nabble.com/how-to-install-OpenBSD-in-a-computer-with-Linux-and-Grub2-td41148.html

Qualquer dúvida, só postar ai nos comentários.

Abraços

Instalando FreeBSD Em Um Cloud Linux

| Comments

A ideia deste tutorial é auxiliar os administradores que precisam adicionar alguma funcionalidade (por exemplo ZFS na raiz) mas não podem personalizar a instalação do FreeBSD no cloud.

Para isso, vamos precisar utilizar uma imagem do Linux com suporte a GRUB e é claro, vamos precisar ter acesso a um KVM para poder gerir o boot do cloud, com isso, vamos fazer o grub carregar na memória uma imagem do FreeBSD na RAM do cloud, de forma que podemos ter o disco disponivel para formatação, a instalação dos binários é pela rede.

Neste exemplo do artigo, vou usar a cloudatcost como provedor de cloud, nele temos uma imagem do Ubuntu Linux disponível e é ela que vamos usar.

Faça o download do arquivo ISO de instalação do mfsBSD (em outro artigo vou explicar o que é isso) na raiz do /boot do Linux:

1
2
cd /boot
wget https://mfsbsd.vx.sk/files/iso/12/amd64/mfsbsd-mini-12.0-RELEASE-amd64.iso

Feito isso, adicione a entrada abaixo no arquivo /etc/grub.d/40_custom

1
2
3
4
5
6
7
8
menuentry "mfsbsd-mini-12.0-RELEASE-amd64.iso" {
    loopback loop (hd0,1)/mfsbsd-mini-12.0-RELEASE-amd64.iso
    kfreebsd (loop)/boot/kernel/kernel.gz -v
    kfreebsd_module (loop)/boot/kernel/ahci.ko
    kfreebsd_module (loop)/mfsroot.gz type=mfs_root
    set kFreeBSD.vfs.root.mountfrom="ufs:/dev/md0"
    set kFreeBSD.mfsbsd.autodhcp="YES"
}

É recomendável também que você aumente o tempo de timeout do grub no arquivo /etc/default/grub para que você possa escolher a opção de carregar o FreeBSD na memoria.

Agora, gere uma nova configuração do grub com o comando abaixo:

1
update-grub

Reinicie o cloud

1
reboot

E pronto !! na hora do boot, no menu do grub, escolha a opção mfsbsd-mini-12.0-RELEASE-amd64.iso e faça a instalação dele !

Para mais informações sobre o mfsBSD, veja em: https://mfsbsd.vx.sk/

Instalação Gitlab No FreeBSD

| Comments

Gitlab Logo

O que é Gitlab ?

Gitlab é um gerenciador de repositorio GIT para o ambiente WEB com a maioria das opções oferecidas pelo o Github. Com o Gitlab você terá a oportunidade de ter seu próprio gerenciador de repositorio, no seu ambiente de trabalho. O projeto é desenvolvido em Ruby com o framework Ruby on Rails.

Veja mais detalhes no site do projeto: https://about.gitlab.org

O que vamos usar ?

Instalação pura do:

FreeBSD 10 amd64 - GENERIC

1
2
# uname -a
FreeBSD gitlab.gugabsd 10.0-RELEASE FreeBSD 10.0-RELEASE #0 r260789: Thu Jan 16 22:34:59 UTC 2014     root@snap.freebsd.org:/usr/obj/usr/src/sys/GENERIC  amd64

Gitlab 7.1 Stable

O que vamos precisar ?

Vamos usar o gerenciador de pacotes binarios PKG para suprir nossa demanda de pacotes dependentes do Gitlab, para isso, execute o comando abaixo para atualizar o pkg:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
root@gitlab:~ # pkg update


The package management tool is not yet installed on your system.
Do you want to fetch and install it now? [y/N]: y
Bootstrapping pkg from pkg+http://pkg.FreeBSD.org/freebsd:10:x86:64/latest, please wait...
Verifying signature with trusted certificate pkg.freebsd.org.2013102301... done
Installing pkg-1.3.6: 100%
Message for pkg-1.3.6:
 If you are upgrading from the old package format, first run:

  # pkg2ng
Updating repository catalogue
Fetching meta.txz: 100% of 944 B                                                                   
Fetching digests.txz: 100% of 2 MB                                                                  
Fetching packagesite.txz: 100% of 5 MB                                                              

Adding new entries: 100%
Incremental update completed, 23436 packages processed:
0 packages updated, 0 removed and 23436 added.

Feito isto, estamos preparado para instalar os pacotes necessários:

1
pkg install -y git redis icu libxml2 libxslt python2 bash sudo gcc gmake

Para o RVM (veremos abaixo):

1
pkg install -y autoconf automake libtool bison readline libyaml sqlite3 gdbm cmake pkgconf

Vamos ligar nosso servidor Redis:

1
2
3
echo 'redis_enable="YES"' >> /etc/rc.conf
/usr/local/etc/rc.d/redis start
Starting redis.

Nesse tutorial, vou fazer uso do Postgresql como base de dados do Gitlab, porém, o Gitlab também é compativel com Mysql, fica a seu criterio:

1
2
3
4
pkg install -y postgresql92-server
echo 'postgresql_enable="YES"' >> /etc/rc.conf
/usr/local/etc/rc.d/postgresql initdb
/usr/local/etc/rc.d/postgresql start

Crie a base que iremos usar com o Gitlab:

1
2
3
4
5
6
7
8
9
10
root@gitlab:~ # su - pgsql
$ psql -d template1
psql (9.2.9)
Type "help" for help.

template1=# CREATE USER git CREATEDB;
CREATE ROLE
template1=# CREATE DATABASE gitlabhq_production OWNER git;
CREATE DATABASE
template1=# \q

Como vamos “enjaular” tudo em um usuário do sistema, vamos cria-lo no FreeBSD com o comando abaixo:

1
pw add user -n git -m -s /usr/local/bin/bash -c "GitLab"

E com o usuário criado, vamos fazer o uso do Ruby, que é a linguagem de construção do Gitlab através do RVM. Para isto, vamos virar usuário git e instalar o ambiente do RVM com uma versão do ruby:

1
2
3
root@gitlab:~ # su - git
[git@gitlab ~]$ 
[git@gitlab ~]$ \curl -sSL https://get.rvm.io | bash -s stable
1
source /home/git/.rvm/scripts/rvm

Agora, instalar o Ruby 2.1.2 necessário para o Gitlab 7.1:

1
2
3
4
5
rvm install 2.1.2

...

Install of ruby-2.1.2 - #complete

Pronto, já estamos com o ambiente com Ruby instalado e preparado para implementar o Gitlab.

1
2
3
4
[git@gitlab ~]$ which ruby
/home/git/.rvm/rubies/ruby-2.1.2/bin/ruby
[git@gitlab ~]$ ruby -v
ruby 2.1.2p95 (2014-05-08 revision 45877) [x86_64-freebsd10.0]

Veja mais informações sobre o projeto RVM em: http://rvm.io/

Começamos então a clonar o repositorio do Gitlab:

1
2
cd
git clone https://gitlab.com/gitlab-org/gitlab-ce.git -b 7-1-stable gitlab

E então, começar a configurar o Gitlab:

Copie o arquivo de exemplo do Gitlab:

1
2
cd /home/git/gitlab
cp config/gitlab.yml.example config/gitlab.yml

ee config/gitlab.yml

  • Altere a entrada localhost para o hostname/dominio completo do seu servidor, por exemplo: gitlab.mundounix.com.br

  • Se for usar https, altere a porta de escuta de 80 para 443

  • Corriga o path do usuário git no arquivo de configuração para o formato /usr/home/git, já que o Gitlab não se da bem com links simbolicos. Faça isso nas linhas: 199, 208, 211, 212 do arquivo.

  • Atualize o cominho do binario do git para o padrão do FreeBSD: /usr/local/bin/git na linha 225

1
cp config/unicorn.rb.example config/unicorn.rb

ee config/unicorn.rb

  • Habilite o modo “cluster” se você tiver muito acesso, aumentando o número de “workes” de acordo com a carga do seu servidor (CPU, Memória, etc)
1
cp config/initializers/rack_attack.rb.example config/initializers/rack_attack.rb

Habilite a configuração da base de dados do Postgresql:

1
cp config/database.yml.postgresql config/database.yml

Configure uma conta global do GIT para o usuario git do sistema:

1
2
3
git config --global user.name "GitLab"
git config --global user.email "exemplo@exemplo.com"
git config --global core.autocrlf input

Acertando algumas permissões:

1
2
3
4
5
6
7
chown -R git log/
chown -R git tmp/
chmod -R u+rwX log/
chmod -R u+rwX tmp/
chmod -R u+rwX tmp/pids/
chmod -R u+rwX tmp/sockets/
chmod -R u+rwX  public/uploads

Criando diretorios para “satellites”:

1
2
mkdir /home/git/gitlab-satellites
chmod u+rwx,g=rx,o-rwx /home/git/gitlab-satellites

Vamos agora instalar os pacotes Gems, que são uma série de libs do Ruby necessárias para o Gitlab funcionar, usando a ferramenta bundle:

1
2
3
4
5
6
7
gem install bundle

export CC=gcc47
export CXX=c++47
export CPP=cpp47

bundle install --deployment --without development test mysql aws

Instalação do Gitlab Shell

GitLab Shell é um software de acesso ssh e gerenciamento de repositório desenvolvido especialmente para GitLab.

Vá para o diretorio de instalação do Gitlab: cd /home/git/gitlab

Rode uma tarefa de instalação do gitlab-shell:

1
bundle exec rake gitlab:shell:install[v1.9.6] REDIS_URL=redis://localhost:6379 RAILS_ENV=production
1
2
3
4
5
6
7
8
# Por padrão, a configuração gitlab-shell é gerado a partir de sua configuração do gitlab principal. 
# 
# Nota: Ao usar GitLab com HTTPS por favor alterar o seguinte: 
# - Fornecer caminhos para os certificados ca_file e ca_path. 
# - A opção "gitlab_url" deve apontar para o https do GitLab. 
# - No caso de você estiver usando o certificado auto-assinado, altere a opção "self_signed_cert" para "true". 
# Você pode rever (e modificar) a configuração gitlab-shell da seguinte forma: 
ee /usr/home/git/gitlab-shell/config.yml

Não esqueça ainda de alterar nesse arquivo de configuração o path (caminho) do usuário git, de /home/git para /usr/home/git na linha 7 do arquivo.

Vamos agora inicializar a base de dados:

1
bundle exec rake gitlab:setup RAILS_ENV=production

Verifique se esta tudo ok:

1
bundle exec rake gitlab:env:info RAILS_ENV=production

Configure o cache de componentes web da interface (assets):

1
bundle exec rake assets:precompile RAILS_ENV=production

Pronto ! Gitlab configurado, precisamos agora configurar a inicilização do mesmo:

Como root (saia do /home do git -> exit):

1
cp /usr/home/git/gitlab/lib/support/init.d/gitlab /usr/local/etc/rc.d/gitlab.sh

Feito isso, vamos inicializar o Gitlab:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
root@gitlab:~ # /usr/local/etc/rc.d/gitlab.sh start
Starting both the GitLab Unicorn and Sidekiq.
The GitLab Unicorn web server with pid 36244 is running.
The GitLab Sidekiq job dispatcher with pid 36271 is running.
GitLab and all its components are up and running.

root@gitlab:~ # ps ax |grep ruby
36244  -  S      0:10.35 ruby: unicorn_rails master -D -c /home/git/gitlab/config/unicorn.rb -E prod
36248  -  S      0:00.00 ruby: unicorn_rails worker[0] -D -c /home/git/gitlab/config/unicorn.rb -E p
36249  -  S      0:00.00 ruby: unicorn_rails worker[1] -D -c /home/git/gitlab/config/unicorn.rb -E p
36271  -  Ss     0:10.15 ruby: sidekiq 2.17.0 gitlab [0 of 25 busy] (ruby)

root@gitlab:~ # sockstat -4l
USER     COMMAND    PID   FD PROTO  LOCAL ADDRESS         FOREIGN ADDRESS      
git      ruby       36249 13 tcp4   127.0.0.1:8080        *:*
git      ruby       36248 13 tcp4   127.0.0.1:8080        *:*
git      ruby       36244 13 tcp4   127.0.0.1:8080        *:*
pgsql    postgres   11726 4  tcp4   127.0.0.1:5432        *:*

Vamos agora configurar um front para nosso Gitlab e para essa tarefa, vamos usar o Nginx. Porém, se você estiver familiarizado com outro servidor web, você poderá também configura-lo, basta consultar o endereço abaixo para mais informações:

https://gitlab.com/gitlab-org/gitlab-recipes/

Vamos instalar o NGINX:

1
pkg install -y nginx

Copie agora o arquivo de configuração pronto do Gitlab para NGINX:

1
cp /usr/home/git/gitlab/lib/support/nginx/gitlab /usr/local/etc/nginx/gitlab.conf
  • Altere o arquivo de acordo com o seu hostname. Isso é importante !
  • Na linha 59, altere a entrada do proxy_pass para o endereço interno do Gitlab: http://127.0.0.1:8080;
  • Na linha 68, comente a entrada “gzip_static on;” colocando um “#” na frente. A versão do nginx compilada para o repositorio pkg não vem com suporte a gzip. Opcionalmente você poderá ativar isso compilando a versão do nginx para o ports.

Adicione agora no arquivo /usr/local/etc/nginx/nginx.conf, antes do ultimo “}”, na linha 117, o include para nosso arquivo de configuração do Gitlab:

1
include /usr/local/etc/nginx/gitlab.conf;

Alguns diretorios necessários para nosso ambiente:

1
2
mkdir -p /var/tmp/nginx /var/log/nginx
chown -R www: /var/log/nginx /var/tmp/nginx

E podemos agora configurar a inicialização do NGINX:

1
2
3
4
5
6
# echo 'nginx_enable="YES"' >> /etc/rc.conf
# service nginx start
Performing sanity check on nginx configuration:
nginx: the configuration file /usr/local/etc/nginx/nginx.conf syntax is ok
nginx: configuration file /usr/local/etc/nginx/nginx.conf test is successful
Starting nginx.

Agora estamos com a configuração completa ! basta apontar seu navegador para o endereço do servidor e se logar com as credenciais padrões de inicialização:

1
2
root
5iveL!fe

É isso, qualquer dúvida, comente abaixo.

Referencias:

https://gitlab.com/gitlab-org/gitlab-ce/blob/7-1-stable/doc/install/installation.md

Usando Pkg Do FreeBSD 10

| Comments

Este é um pequeno tutorial, na verdade uma dica rápida de como funciona o sistema de gerenciamento de pacotes binários do FreeBSD 10 – pkg

Dúvidas em relação a dica podem ser postadas nos comentários abaixo:

Lançado a Versão 9.2 Do FreeBSD

| Comments

A equipe de lançamento do projeto FreeBSD acaba de anunciar a disponibilidade da versão 9.2 do FreeBSD. Este é o segundo release da arvore estavel da familia 9 que provê mudanças de melhorias e estabilidade em relação ao FreeBSD 9.1 e introduz algumas novas caracteristicas, que podem ser resumidas abaixo:

  • O sistema de arquivo ZFS suporta agora o TRIM para ser usado em discos SSD.
  • Drivers de emulação virtio(4) foram adicionados no kernel GENERIC em arquiteturas amd64 e i386.
  • O sistema de arquivo ZFS suporta agora compressão lz4.
  • OpenSSL foi atualizado para a versão 0.9.8y.
  • DTrace agora esta habilitado por padrão no kernel GENERIC.
  • DTrace foi atualizado para a versão 1.9.0.
  • Sendmail foi atualizado para a versão 8.14.7.
  • OpenSSH foi atualizado para a versão 6.2p2.

Para uma lista completa das novas funcionalidades e da resolução de problemas conhecidos, acesse os links abaixo (em inglês):

Veja o anuncio completo no link abaixo:

http://lists.freebsd.org/pipermail/freebsd-announce/2013-September/001504.html

Pfsense 2.1 RELEASE Lançado Oficialmente

| Comments

A equipe de desenvolvimento do firewall Pfsense, com muito orgulho, anuncia no dia de hoje o lançamento da versão 2.1 do Pfsense, trazendo uma série de novidades, como o suporte a IPv6 nativo na interface de configuração.

Algumas mudanças se destacam:

  • Multiplos ambientes de Captive Portal
  • PBI (do PCBSD) como gerenciador de pacotes de softwares
  • Atualização do sistema base do FreeBSD para a versão 8.3
  • Adição de suporte a mais hardwares
  • PHP atualizado para a versão 5.3
  • Suporte a outras linguas (pt_BR já incluido)

Entre muitas outras alterações documentadas no blog do projeto.

Veja o link abaixo para maiores detalhes:

http://blog.pfsense.org/?p=712

Gravação Do Hangout Tutorial Traffic Shaper No Pfsense

| Comments

Mais um Hangout Tutorial finalizado e com a dignissima participação em sala cheia de vários usuários, muito obrigado a todos que participaram interativamente e também via youtube ao-vivo. Foi bem legal.

O Hangout de hoje tratou do tema de controle de banda ou qualidade de serviço no Pfsense, entitulado “Traffic Shaper”, abordamos os conceitos de utilização de cada tipo de algoritmo e funcionalidade de cada um no ambiente do Pfsense.

Tivemos a oportunidade de criar cenários de utilização e aplicação de regras para melhorar o controle de trafego da rede e elucidamos várias duvidas pertinentes à utilização de QOS.

Confira abaixo, a integra desse Hangout:

E se você tiver alguma dúvida, poste um comentário abaixo.

Abraços !