Após ter divulgado o rocket-chat, várias pessoas perguntaram como adicionar ao arranque automático, ou criar um atalho. Isto porque não sabiam como encontrar o “executável”…
Fica aqui o caminho para o executável do Rocket-chat:
/opt/rocketchat/rocketchat
Todos precisamos de vez em quando de uma ferramenta para uma conversa rápida, anónima e sem grandes configurações. Ao navegar pela Internet encontrei vários serviços de chat que me ofereciam tudo isso mas houve um que me agradou mais.
O ChatCrypt é um serviço de chat simples e directo.
Escolhemos um nome para a sala, um utilizador e uma palavra-chave. É aberta uma nova janela de chat.
Cada pessoa que quiser entrar só tem de colocar o nome da sala e palavra-passe correctas. Quem tentar entrar na sala sem ter a password correcta, não vai conseguir ler o que os restantes membros escrevem.
Isto porque, de acordo com os autores do chat a encriptação ocorre antes da nossa mensagem sair do navegador que estamos a usar, utilizando para isso o algoritmo AES-256 no modo CTR com uma palavra-passe especificada pelo utilizador.
Os criadores foram ainda mais longe e permitem que possamos usar este serviço numa pagina externa à do serviço, como por exemplo numa página gerida por nós.
Lembrei-me logo do Raspberry 🙂
Num Raspbian criado de fresco apenas tive que instalar o Apache:
sudo apt-get install apache2
Depois Criei um ficheiro dentro da pasta /var/www/html/
nano /var/www/html/chat.html
Inseri o seguinte conteúdo:
Salvei o ficheiro e acedi ao raspberry:
http://ip_do_raspberry/chat.html
Experimentem!
Rocket Chat é um serviço de conversação online, mais uma fantástica pérola do mundo open-source.
Destaco (entre muitos) os seguintes serviços:
Ao nível de cliente é suportado pelos principais sistemas operativos Linux, Windows e OSX. Também tem cliente nativo para Android e IOS. Podem ver uma demonstração aqui.
Ao nível de servidor, obviamente pode ser instalado num Linux. Vamos usar o nosso Raspberry? 🙂
Para o efeito vou usar um Raspberry Pi 2, com um cartão SD 8GB classe 10.
O sistema operativo é o Ubuntu server, instalado de fresco e actualizado.
Primeiro actualizamos e instalamos algum software adicional:
sudo apt-get update
sudo apt-get dist-upgrade
sudo apt-get install git curl graphicsmagick python build-essential
Vamos agora instalar e configurar a nossa base de dados, usando para o efeito o Mongo:
sudo apt-get install mongodb
Iniciamos a configuração do nosso Mongo:
mongo admin
Configuramos o administrador (alterem o “admin” e “1234“) :
db.createUser({ user: “admin”, pwd: “1234”, roles: [“userAdminAnyDatabase”] })
auth = true
setParameter = enableLocalhostAuthBypass=0
Configuramos a base de dados e o seu administrador para o nosso chat:
use chat_db
db.createUser({ user: “user”, pwd: “1234”, roles: [“readWrite”] })
exit
Em seguida obtemos o METEOR para o ARM:
cd /tmp
git clone –depth 1 https://github.com/4commerce-technologies-AG/meteor.git
meteor/meteor -v
Hora para tomar um café 🙂
No fim do processo vamos então criar uma pasta onde o nosso Rocket chat vai ser instalado:
sudo mkdir /opt/chat
cd /opt/chat
sudo curl https://cdn-download.rocket.chat/build/rocket.chat-pi-develop.tgz -o rocket.chat.tgz
sudo tar zxvf rocket.chat.tgz
Movemos para a nossa nova pasta o Meteor:
sudo mv /tmp/meteor /opt/chat/
E agora instalamos as dependências e finalmente o nosso chat:
cd bundle/programs/server
/opt/chat/meteor/dev_bundle/bin/npm install
cd /opt/chat/bundle
Agora, numa só linha:
PORT=3000 ROOT_URL=http://raspberry_IP:3000 MONGO_URL=mongodb://user:1234@localhost:27017/chat_db /opt/chat/meteor/dev_bundle/bin/node main.js
Após o processo entramos na página do nosso chat:
http://ip_do_raspberry:3000 (Podem alterar o numero da porta caso desejem)
Registem um utilizador que será automaticamente Admin do sistema.
Vão a Administration -> Email -> SMTP e configurem uma conta para envio de email.
E pronto! Temos o nosso Rochet.Chat a postos para a conversa. Podem instalar o cliente da Rocket.Chat ou usar a plataforma WEB.
Vamos agora arranjar um scrit para arrancar com o nosso chat server de uma forma mais fácil. Há várias maneiras de fazer isto pelo que fica aqui uma bastante fácil. Vamos criar um ficheiro com o nome server.conf
cd /opt/chat/bundle
nano server.conf
Vamos inserir a seguinte informação:
#!/bin/bash
export PORT=3000
export ROOT_URL=http://raspberry_IP
export MONGO_URL=mongodb://user:1234@localhost:27017/chat_db
/opt/chat/meteor/dev_bundle/bin/node main.js
Guardamos e damos permissões de executável:
chmod +x server.conf
Agora arrancamos com o nosso script com a ajuda do screen:
screen
cd /opt/chat/bundle
./server.conf
Após uns minutos temos o nosso servidor novamente no ar.
Para sair da sessão do screen carreguem as teclas Ctrl+a+d
Para voltar à sessão escrevam na consola:
screen -r
Mais informações do screen podem ver aqui.
Não esqueçam que esta instalação é básica e há questões relacionadas com segurança que deverão ser levadas em conta. Passwords fortes e uma firewall é o primeiro caminho a percorrer antes de abrir o nosso chat ao mundo. Outras opções serão apresentadas em futuros artigos.
Cumprimentos!
A Canonical suporta oficialmente o Ubuntu no Raspberry Pi 2 (também disponibilizam uma imagem para o Raspberry 3)!
Podem fazer download da imagem aqui para o vosso Pi 🙂
Como instalar? Na consola do nosso Ubuntu e já com o cartão SDCard do Raspberry inserido verificamos o path para o cartão (que deverá ser /dev/mmcblk0) com o seguinte comando:
lsblk
Em seguida fazemos download da imagem:
cd /tmp
wget http://cdimage.ubuntu.com/ubuntu/releases/16.04/release/ubuntu-16.04-preinstalled-server-armhf+raspi2.img.xz
E instalamos no cartão:
xzcat ubuntu-16.04-preinstalled-server-armhf+raspi2.img.xz | sudo dd of=/dev/mmcblk0
Esta imagem é para um cartão de 4Gb. Podem preencher o resto do cartão com recurso ao GPARTED. Se não o tiverem basta instalar com sudo apt-get install gparted.
No primeiro arranque autentiquem-se com username ubuntu e password ubuntu. Vai ser solicitada a alteração para uma nova password.
A instalação do Ubuntu no Raspberry traz algumas vantagens relativamente ao Debian das quais destaco o Kernel mais recente e pacotes de instalação mais actuais. Isto pode ser útil em algumas situações. Experimentem!
Uma boa função para o nosso Raspberry é ser um servidor NTP na nossa rede local.
A sua configuração é bastante simples
Começamos por actualizar o sistema:
sudo apt-get update
sudo apt-get dist-upgrade
Garantimos que o nosso Raspberry está na zona correcta:
sudo dpkg-reconfigure tzdata
(Escolher Europa e depois Lisboa)
Instalamos o NTP:
sudo apt-get install ntp
Editamos o ficheiro de configuração:
sudo nano /etc/ntp.conf
Primeiro comentamos os servidores existentes:
# Use servers from the NTP Pool Project. Approved by Ubuntu Technical Board
# on 2011-02-08 (LP: #104525). See http://www.pool.ntp.org/join.html for
# more information.
# pool 0.ubuntu.pool.ntp.org iburst
# pool 1.ubuntu.pool.ntp.org iburst
# pool 2.ubuntu.pool.ntp.org iburst
# pool 3.ubuntu.pool.ntp.org iburst
# Use Ubuntu’s ntp server as a fallback.
# pool ntp.ubuntu.com
Em seguida acrescentamos os portugueses:
# Servidores portugueses
server 2.pt.pool.ntp.org
server 1.europe.pool.ntp.org
server 0.europe.pool.ntp.org
Logo a seguir permitimos pedidos NTP apenas na nossa rede local:
# Permitir apenas a rede local
restrict 10.0.0.0 mask 255.255.255.0 nomodify notrap
(Ajustar a rede para a vossa rede local)
Salvamos o ficheiro e reiniciamos o serviço NTP:
sudo service ntp restart
Verificamos o estado:
ntpq -p
Deveremos obter uma mensagem assim:
==============================================================================
+2.pt.pool.ntp.o 194.117.9.136 3 u 37 64 1 26.271 0.666 0.001
*1.europe.pool.n 81.2.117.235 2 u 36 64 1 55.100 1.474 0.001
+0.europe.pool.n 192.33.96.102 2 u 40 64 1 74.266 2.486 0.001
E pronto! Não esquecer de abrir a porta 123 UDP caso usemos uma firewall.
Um dos artigos do meu blog mais visitados é sem dúvida o Raspberry social server, que permite ter varias contas IM online simultaneamente, com um único login. No entanto a Ignite tem mais uns projectos interessantes para o nosso Raspberry, dos quais destaco o SparkWeb.
SparkWeb é uma simples página de Chat, suportada pelo servidor Openfire.
Começamos? 🙂 Embora pra consola
Precisamos de um servidor Ubuntu ou Debian, (testei com 1GB Ram). No caso do Raspberry2 já vem com Debian na imagem oficial Raspbian. Os comandos seguintes vão funcionar tanto em Ubuntu como em Debian.
Vemos se o sistema está totalmente atualizado
sudo apt-get update && sudo apt-get dist-upgrade
e reiniciamos o sistema.
Verificamos se temos o Java7 instalado:
java -version
Caso não esteja instalado executamos:
sudo apt-get install openjdk-7-jre-headless
De seguida instalamos o Apache
sudo apt-get install apache2
Criamos uma pasta onde vamos realizar alguns Downloads:
mkdir downloads
cd downloads
Descarregamos o Openfire:
wget http://www.igniterealtime.org/downloadServlet?filename=openfire/openfire_3.10.2_all.deb -O openfire_3.10.2_all.deb
e instalamos:
sudo dpkg -i openfire_3.10.2_all.deb
Descarregamos o SparkWeb:
wget http://www.igniterealtime.org/downloadServlet?filename=sparkweb/sparkweb_0_9_0.zip -O sparkweb_0_9_0.zip
descompactamos e colocamos no sítio:
unzip sparkweb_0_9_0.zip && sudo cp sparkweb/* /var/www/html/
e por fim corrigimos permissões:
sudo chown -hR www-data:www-data /var/www/html
Agora podemos configurar o nosso servidor Openfire via web:
http://ip_da_maquina:9090
Escolhemos a linguagem preferida:
Escolhemos o nome do domínio e criamos uma chave de encriptação
Decidimos que tipo de base de dados vamos usar:
Escolhemos o tipo de autenticação:
Definimos a conta de admin
E terminamos a configuração. Simples, não?
Autenticamo-nos
Na consola de admin vamos a Servidor > Configurações do Servidor > Registro&Login e desactivamos o Login anónimo
Em seguida criamos um ou mais utilizadores
Vamos a Grupos e criamos um
Na aba Conferência criamos uma nova Sala
Vamos a Plugins > Plugins disponíveis e instalamos o Client Control
Agora vamos a Servidor > Gerenciamento de cliente > Marcadores… e adicionamos a sala que criámos na aba Conferência. Não esquecer de adicionar todos os utilizadores e o Auto-ingressar:
E pronto, já podemos usar a nossa sala de chat via web, via http://ip_do_servidor/SparkWeb.html
Autenticamo-nos e deveremos entrar automaticamente na sala criada:
E pronto! Para o nosso servidor ficar diponível para o mundo basta reencaminhar as portas TCP 80 e 5222 no nosso router. Neste caso o IP a usar será o nosso IP externo ou um endereço dinâmico tipo no-ip.com. Já podemos convidar os nossos amigos e divertirmo-nos por uma boas horas 🙂
Algumas considerações finais:
– O Setup apresentado tem apenas o mínimo de configurações para o objectivo apresentado, não sendo no entanto o ideal para um ambiente de utilização intensa.
– Há mais algumas configurações na consola de admin que vocês devem explorar. Caso queiram há algumas alterações que podem fazer no ficheiro /var/www/html/SparkWeb.html, ao nível do IP e porta de comunicação.
– Podem usar um cliente para se ligarem, tipo Pidgin ou Spark.
– Por fim, há outros sistemas mais recentes e mais completos mas também mais complexos para implementar, Este sistema é simples e prático e com algum conhecimento pode ser bem robusto para um ambiente de produção. E corre perfeitamente num Raspberry2 🙂
Cumprimentos linuxianos
Um dia destes ao falar com um amigo meu que tinha comprado um raspberry, perguntei todo entusiasmado o que já tinha feito quando ele triste me responde que “dá muito trabalho escrever o comboio de comandos que aparecem nos artigos!”
Bom, sei que isto parece estranho de dizer mas os maluquinhos de Linux são tão preguiçosos como os outros e fazem tudo para facilitar a vida no dia-a-dia!
Para acedermos a um Raspberry e inserir os comandos que vemos na Internet não precisamos de escrever no teclado local. Podemos fazer isso com um “copiar & colar”, a partir do nosso computador pessoal, usando para isso um protocolo de nome SSH. Aliás, podemos fazer tudo como se tivéssemos ligados directamente ao Raspberry desde que este esteja ligado pelo menos com o cabo de rede, no mesmo Router onde o nosso computador pessoal está ligado. A única informação que precisamos é de saber qual o IP do nosso Raspberry. Para isso basta ver no arranque do nosso Raspberry o IP:
Neste caso é o IP 192.168.1.15.
Também é possível ver com o comando ifconfig:
Neste caso é o IP 192.168.1.70
Assim, já temos como aceder ao nosso Raspberry. Vamos imaginar que o IP do nosso Raspberry é o 192.168.2.100 e que o utilizador é o “pi“.
Em Linux ou em OSX abrimos uma consola e escrevemos “ssh pi@192.168.2.100“. Se o sistema conseguir chegar ao nosso Raspberry, vai ser pedida a password (por defeito é Raspberry). E pronto, é como se estivéssemos ligados directamente no nosso Raspberry!
Em Windows podemos usar um programa muito simples mas poderoso, de nome Putty. O programa não exige instalação e é um só ficheiro.
No hostname escrevemos o IP do nosso Raspberry e clicamos em Open. Abre-se uma janela de consola onde inserimos o utilizador e password. E pronto! Já podemos copiar os comandos dos milhares de projectos que há pela Internet para o nosso Raspberry, sem ter que os escrever. Para “colar” no Putty basta clicar com o botão direito do rato na consola.
Bons projectos! 🙂
Recebi há dias a mais recente versão do Raspberry Pi! Mais potente e melhor equipado, o novo Raspberry 2 Modelo B destaca-se da anterior versão por ter um ARMv7 Quad core @ 900MHz, 1GB RAM, entre outras caracteristicas. O fabricante garante 6x mais performance relativamente à versão anterior.
Com a minha habitual euforia de brinquedo novo na bancada, tive que decidir qual o primeiro projeto para testar o bicho…
Dispensa apresentações. É das melhores senão a melhor solução open-source para a nossa “nuvem” privada. Já vai na versão 8.
Vamos então para o nosso plano de trabalho:
HARDWARE
1 Raspberry com cartão microSD de 8GB Classe 10
1 Pen ou Disco externo USB para armazenamento de dados
SOFTWARE
Sistema operativo Raspbian
Instalação de LAMP (Apache + MySQL + PHP)
Instalação e configuração inicial do ownCloud
Vou partir do princípio que o raspberry está com a versão Raspbian instalada, configurada e atualizada. O site do Raspberry tem bons tutoriais para esse efeito.
1- Preparação da PEN/HDD USB com o seguinte comando:
sudo fdisk -l
Na resposta deverá aparecer alguma coisa tipo:
Device Boot Start End Blocks Id System
/dev/sda1 * 2048 30297215 15147584 c W95 FAT32 (LBA)
Poderá aparecer sdb, sdc, etc. No meu caso é uma PEN USB de 16GB.
Vamos formatar o nosso /dev/sda1 com EXT4, um formato nativo de Linux:
sudo mkfs.ext4 /dev/sda1
Em seguida criamos a pasta onde a informação da nossa nuvem vai ficar guardada e montamos a nossa PEN/HDD USB:
sudo mkdir /cloud
sudo mount /dev/sda1 /cloud
Podem alterar o nome da pasta /cloud para o que quiserem.
Damos as permissões corretas à pasta criada (para depois o ownCloud funcionar bem):
sudo chown www-data:www-data /cloud
Para tornar este mount permanente fazemos o seguinte:
sudo nano /etc/fstab
Deverá aparecer a seguinte informação:
proc /proc proc defaults 0 0
/dev/mmcblk0p1 /boot vfat defaults 0 2
/dev/mmcblk0p2 / ext4 defaults,noatime 0 1
É só acrescentar:
/dev/sda1 /cloud ext4 defaults 0 2
Pronto, o nosso raspberry já pode reiniciar.
2- Vamos configurar agora o nosso raspberry como um servidor LAMP (Apache + MySQL + PHP) e instalar o necessário para a nossa “nuvem” pessoal:
sudo apt-get install apache2 mysql-server php5 php-pear php5-mysql php5-gd php5-curl
Na instalação do MySQL o sistema vai pedir-nos para definirmos uma password de root (não tem nada a haver com o root de sistema).
3- Vamos tornar o nosso MySQL mais seguro:
sudo mysql_secure_installation
Caso tenham dúvidas vejam um bom exemplo aqui.
Vamos aproveitar para criar um utilizador MySQL e a base de dados para o ownCloud:
mysql -uroot -p
Insiram a password definida na instalação do MySQL. Criamos primeiro o utilizador:
CREATE USER ‘username’@’localhost’ IDENTIFIED BY ‘password’;
Alterem o username e a password para o que quiserem. Não esqueçam os ‘ e o ; no fim! Agora vamos criar a base de dados e dar permissões ao user criado:
CREATE DATABASE cloud_db;
GRANT ALL PRIVILEGES on cloud_db.* to username@localhost;
FLUSH PRIVILEGES;
exit
Podem (e devem) alterar o nome da cloud_db para o que quiserem.
E pronto. Vamos para a etapa seguinte!
4- Vamos agora ativar o SSL. Começamos por gerar uma chave:
sudo mkdir /etc/apache2/ssl
sudo openssl req -x509 -nodes -days 1001 -newkey rsa:2048 -keyout /etc/apache2/ssl/apache.key -out /etc/apache2/ssl/apache.crt
Podem alterar os dias para o numero que quiserem. Respondam às perguntas seguintes. Por fim, vamos editar o ficheiro seguinte:
sudo nano /etc/apache2/sites-available/default-ssl
Logo por baixo de ServerAdmin coloquem
ServerName nome_da_maquina.com:443
O nome nome_da_maquina.com é o FQDN. Em caso de dúvida coloquem server.lan.
Mais abaixo, alterem o caminho dos certificados:
SSLCertificateFile /etc/apache2/ssl/apache.crt
SSLCertificateKeyFile /etc/apache2/ssl/apache.key
Salvamos o ficheiro e finalizamos com os seguintes comandos:
sudo a2ensite default-ssl
sudo a2enmod ssl
sudo service apache2 reload
Podem testar abrindo o browser no https://ip_do_raspberry
5- Descarregamos a versão mais recente do ownCloud (à data deste post), descompactamos o ficheiro e copiamos para a pasta www:
wget https://download.owncloud.org/community/owncloud-8.0.0.tar.bz2
tar -xvf owncloud-8.0.0.tar.bz2
sudo rm /var/www/*
sudo cp owncloud/* /var/www/ -r
Corrigimos as permissões:
sudo chown -hR www-data:www-data /var/www/
(este comando permite ao apache ter controlo total da pasta do ownCloud)
Vamos então configurar o ownCloud:
https://ip_do_raspberry
Se tudo correu bem vão encontrar o seguinte ecrã, onde poderão criar um utilizador de administração e inserir a informação previamente criada:
E pronto, já podem começar a configurar a vossa nuvem pessoal!
Podem começar por configurar as opções gerais, no menu de administração:
Boa nuvem! 🙂
Para mim, o único defeito do fantástico Raspberry é o sistema de armazenamento de dados assentar num cartão SD. Bem que podia ter uma interface SATA mas… o seu preço não seria o que é! Resta aceitar e tomar as devidas precauções para não apanharmos sustos de cada vez que reiniciamos o sistema ou quando inadvertidamente retiramos a energia eléctrica.
Podemos sempre fazer backup dos dados para uma pen USB ou para um servidor remoto via FTP mas muitas vezes fazemos alterações e personalizamos o sistema operativo, o que após uns meses se torna difícil reconstruir do zero e pôr o nosso Raspberry tal e qual estava antes da “desgraça”. Por outro lado, os cartões SD mais usados são por norma de 4 a 32GB. Então, porque não criar uma imagem total do cartão SD?
Começamos então por desligar o nosso Raspi:
sudo poweroff
Esperamos que as luzes se apaguem excepto a vermelha. Podemos então desligar da corrente e retirar o nosso cartão. Inserimos o cartão no nosso computador. A única preocupação ver é se tem o espaço livre suficiente para albergar o tamanho máximo do cartão no disco do computador.
Em Windows podem usar a ferramenta Win32DiskImager.
Em Linux vamos usar a poderosa ferramenta dd.
Na consola, verificamos primeiro onde está o nosso cartão:
sudo fdisk -l
No meu caso é /dev/sdb
Executamos então o seguinte comando:
sudo dd bs=4M if=/dev/sdb | gzip > /home/utilizador/raspberry.gz
Não vai haver barra de progresso e só resta aguardar que termine. Com este comando o ficheiro criado é automaticamente comprimido.
E pronto, temos o nosso backup realizado! 🙂
Caso pretendam repor a cópia ou trocar de cartão SD basta inverter o processo:
sudo gzip -dc /home/utilizador/raspberry.gz | dd bs=4M off=/dev/sdb
Limpinho, limpinho 🙂
Já ninguém duvida das fantásticas possibilidades e vantagens que os Raspberry Pi trouxeram ao mundo informático. Com um baixo consumo, tamanho pequeno e uma tremenda simplicidade temos na nossa mão um poderoso “brinquedo” que tem como limite a nossa imaginação.
No entanto, sempre achei que o ponto fraco deste equipamento se encontra no armazenamento por ser um cartão SD. A probabilidade de o cartão se danificar ou ficar com dados corrompidos é elevada se abusar do overclock ou de programas com escrita em disco intensiva (como por exemplo uma base de dados). Como ultrapassar este problema? Simples, usamos um disco externo ou uma pendrive e apontamos para lá o directório que queremos.
Vamos imaginar que queremos um servidor Minecraft a correr no nosso Raspi mas queremos que todo o programa corra dentro de uma Pendrive. O Minecraft vai ser instalado no directório /minecraft. A pendrive usada deverá ser formatada com o sistema EXT3. Porquê? Porque este formato é rápido, nativo de Linux e não tem o journaling do EXT4 (que tornaria o sistema mais lento).
1- Na consola, passamos para su:
sudo su
2- Criamos o directório de instalação do Minecraft:
mkdir /minecraft
3- Já com a pen inserida no Raspi, detectamos qual o caminho para a pen:
fdisk -l
Como podem ver, o caminho neste caso é /dev/sda1
4- Vamos inseri-lo no ficheiro /etc/fstab:
nano /etc/fstab
É só acrescentar a ultima linha
/dev/sda1 /minecraft /ext3 defaults,noatime,nodiratime 0 0
salvar e sair
5- Reiniciamos a máquina
reboot
6- Se tudo correu bem temos a pen montada no directório pretendido. Entramos na pasta
cd /minecraft
Em seguida basta instalar o Minecraft no directório em questão e já está! Temos a nossa aplicação a correr na pendrive!
papiMigas 