Criar um servidor Nextcloud (Debian 8/Ubuntu Xenial)

Para quem não conhece, o Nextcloud é um fork do ownCloud. À parte das divergências (tal como existiram na separação do OpenOffice.org) este projecto está a evoluir fortemente. Na primeira fase foi retro-compatível com o ownCloud, mas neste momento, com o lançamento da versão 10, já diverge em algumas configurações. Parece que muitos dos bugs com WebDAV e CalDAV foram corrigidos e a implementação é mesmo diferente do seu antecessor.

Mais uma vez quero aprender as coisas como deve ser e decidi fazer tudo “à patinha”. Existem muitos tutoriais por aí, mas deixo aqui alguns que me ajudaram em todo o processo:

Servidor/Maquina Virtual

Para a esta opção, usei a distribuição Debian, e fui buscar as versões mais mini, as netinstall disponíveis aqui, usado a versão i386 compatível com a máquina, um Toshiba NB500 (sim, incrivelmente e aguenta-se bastante bem).

Raspberry Pi v2/3

Para esta implementação já estou a usar varias distros, as quais deixo abaixo:

Quem já me segue já sabe que para este tipo de solução é desaconselhável a utilização do Rasp v1. Para escrever para o SD, usar o Win32Disk Imager. Não esquecer de usar uma partição/formatar o SD em FAT32.

OrangePi Zero

Orange Pi ZeroEstou a montar um servidor de testes para uma empresa que tem muitos poucos utilizadores, e nada como usar algo bem mais barato que algumas soluções que existem no mercado, ainda mais quando esta pode ser completamente configurada e adaptada ao contexto. Para este caso, mantendo a opção Debian, decidi usar a distribuição armbian, que tem um ISO optimizado para OPiZero. Para outro teste estou a usar o Ubuntu Xenial, pois já conta com PHP7 nos repositórios (para armhf, ao contrário de Debian).

De notar que, não tendo saída HDMI (apesar de ter uma saída S-Video), o mais fácil é tentar perceber qual o IP que ele recebeu por DHCP no vosso router. A mim apareceu-me como:

fe:2c:24:b5:56:29 10.0.0.16 orangepizero

Preparação do servidor

A preparação do servidor tem como base todas as minhas anteriores configurações em Debian e raspberry pi, mas como esta nuvem pretende ser um servidor mais empresarial, decidi usar um ambiente mais estável e robusto assente em PostreSQL.

Durante a instalação do debian 7/8 escolher no Software selection o mais simples possível, seleccionando apenas o SSH server e Web Server.

Configuração de rede

IP Fixo

Visto que este irá ser um servidor empresarial convém o mais possível que o IP seja fixo (até porque vão precisar dele fixo mais tarde). Usei a ajuda da Debian para o fazer, disponível aqui. Esta configuração é aplicavel também em Ubuntu e todas as distros Debian based.

Para definir o IP fixo, editar:

nano /etc/network/interfaces

E depois definir à eth0 os seguintes valores (substituir pelos vossos):
PS: No Ubuntu14.x e Debian 8 é provável que encontrem algum texto novo, colocar a configuração estática debaixo de: “source-directory /etc/network/interfaces.d”. Em Ubuntu também vos indicam utilizar o nmtui, esqueçam…

auto eth0
iface eth0 inet static
        address 10.0.0.25
        netmask 255.255.255.0
        gateway 10.0.0.1
        network 10.0.0.0
        broadcast 10.0.0.255

Recordar que, podem incluir duas, ou mais, configurações de IP, especialmente quando estão a trabalhar em duas redes distintas. É só adicionar a partir de iface. A seguir convém sempre reiniciar a placa de rede para ela poder assumir o IP atribuído:

ifdown eth0
ifup eth0

DNS’s

Em alguns casos será também boa ideia definir os servidores de resolução de nomes:

nano /etc/resolv.conf

E adicionar os seguintes, OpenDNS e Google DNS, respectivamente alterado:

nameserver 208.67.222.222
nameserver 8.8.8.8
nameserver 208.67.220.220
nameserver 8.8.4.4

Hostname

Se também quiserem mudar o nome da máquina, para que fique mais apelativo dentro da rede (até porque no meu caso vou usar também partilhas Samba), basta editar os ficheiros:

nano /etc/hostname
nano /etc/hosts

No segundo deverá constar na mesma o localhost, e por baixo o nome da máquina:

127.0.0.1 localhost
127.0.0.1 Nextcloud

Atribuir a ambos o nome desejado e depois reiniciar o sistema (isto porque é a melhor maneira de garantir que o nome fique realmente atribuído).

Ubuntu

Desinstalar o pacote cloud-init

Preparar o servidor SSH

Debian

Por defeito o servidor SSH também não vem instalado. Para continuarem a configuração no conforto do “sofá” basta seguir a help do Debian e:

apt-get install openssh-server

E em principio já podem aceder remotamente a partir da vossa rede interna. No entanto, no Debian 8 o acesso SSH remoto está desactivado por defeito. Para o activar, aceder a

nano /etc/ssh/sshd_config

e depois alterar a linha “PermitRootLogin without-password” para:

PermitRootLogin yes

E não esquecer depois de reiniciar o servidor de SSH

service ssh restart

Ubuntu

Se estiverem em Ubuntu, é muito provável que o sevidor SSH já esteja instalado, mas que não permita o acesso por root, para isso terão de primeiro efectuar os mesmos passos acima, depois mudar a pass de root e activar a mesma.

sudo passwd root

Aqui vai ser pedida a pass, e a respectiva confirmação, depois correr

sudo passwd -u root

Se ao correr o comando for dada a seguinte informação:

passwd: password expiry information changed

É porque tudo correu bem. Para voltar a fechar o acesso, basta rever a opção do servidor SSH, e correr o comando:

sudo passwd -l root

Instalar o Apache

De notar que nas versões:

  • Debian Whezzy (7.x) = Apache 2.2.x
  • Debian Jenny (8.x)/Ubuntu 16.04.x = Apache 2.4.x.
apt-get install apache2

Instalar o PostgreSQL (9.4/9.5/9.6)

Depois das configurações típicas na instalação, na qual escolhi também a opção de servidor de base de dados, o Debian instalou-me automaticamente o PostgreSQL.  Se não instalaram de início podem instalar com:

apt-get install postgresql postgresql-contrib

O utilizador e a base de dados criadas por defeito têm o nome postgres.  Para o definir-mos, mudar de utilizador com:

su - postgres

E aceder ao servidor postgres:

psql

A password do utilizador deve ser mudada através de:

\password postgres 
Enter new password: 
Enter it again:

Aproveitamos já para instalar o admin pack

CREATE EXTENSION adminpack;
\q

\q permite sair do servidor postgres.

Uma alteração que deverá ser feita é a activação da autenticação por MD5. PostgreSQL-MD5 Authentication:

#debian8/xenial
nano /etc/postgresql/9.4/main/pg_hba.conf
nano /etc/postgresql/9.5/main/pg_hba.conf
nano /etc/postgresql/9.6/main/pg_hba.conf

E encontrar as seguintes linhas e alterar de “peer” ou outro para “md5”.

local   all             postgres              md5
local   all             all                   md5

Se quiserem saltar o passo seguinte, sem ter a necessidade de instalar o phpPgAdmin, podem criar o utilizador e a base de dados da seguinte forma, acedendo ao pgsql:

psql -hlocalhost -Upostgres
CREATE USER username WITH PASSWORD 'password';
CREATE DATABASE nextcloud TEMPLATE template0 ENCODING 'UNICODE';
ALTER DATABASE nextcloud OWNER TO username;
GRANT ALL PRIVILEGES ON DATABASE nextcloud TO username;
\q

Conexões TCP do PostgreSQL (se necessário)

Por vezes não é necessário efectuar esta alteração. Só em alguns sistemas, por defeito, todas as conexões TCP/IP estão desabilitadas. Para activar, aceder ao ficheiro:

#debian8/xenial
nano /etc/postgresql/9.4/main/postgresql.conf
nano /etc/postgresql/9.5/main/postgresql.conf
nano /etc/postgresql/9.6/main/postgresql.conf

E encontrar a linha #listen_addresses = ‘localhost’, descomentar e alterar para o IP fixo definido:

listen_addresses = '10.0.0.25'

E descomentar igualmente a linha:

password_encryption = on

Agora é só reiniciar o servidor (e ver se tudo corre bem):

service postgresql restart

Se o nextcloud, depois da introdução dos dados da base de dados, retornar um “Internal Server Error”, voltar a colocar em ‘localhost’.

Instalar o phpPgAdmin

Para preparar e administrar a base de dados, gosto sempre de ter à mão uma interface que me ajude a descortinar alguma coisa no meui de tanto preto e branco. Para isso costumo usar o phpMyAdmin para mySQL. No caso de PostgreSQL a solução é o phpPgAdmin.

apt-get install phppgadmin

Por defeito o phpPgAdmin não é acessível fora do sistema local (de fora da máquina). Para isso alterar o ficheiro:

#debian8
nano /etc/apache2/conf-enabled/phppgadmin.conf

E descomentar a linha que diz:

#debian8
Require local
Require all granted

E por fim, reiniciar o apache:

service apache2 restart

Agora é só aceder ao vosso ip por http:

http://10.0.0.25/phppgadmin

Se ao tentar entrar com o utilizador postgres:password o phpPgAdmin devolver o erro:

Login disallowed for security reasons.

Editar a configuração do phpPgAdmin para:

nano /usr/share/phppgadmin/conf/config.inc.php

E alterar as seguintes linhas:

$conf['servers'][0]['host'] = '';
$conf['extra_login_security'] = false;

Agora com certeza é possível fazer login no phpPgAdmin, podendo ser possível criar utilizadores e bases de dados, e dar as respectivas permissões. Convém que façam já um utilizador e uma base de dados para o ownCloud.

NOTA: O nome de utilizador segue as mesmas regras que os utilizadores *linux, portanto, nada de caracteres estranhos como hífens e afins.

PHP5/7

Em primeiro lugar instalar alguns pacotes que vamos precisar, primeiro os de PHP, e depois o SMB client (cliente samba para as partilhas). Devido a muitas actualizações que foram feitas, e especialmente devido à performance, estou a testar PHP7. O Debian 8.x não vem com os repositórios para PHP7, o que já não acontecerá com o Debian 9.x, e por isso temos de as ir buscar ao dotdeb(amd64/i386) ou ao MooPi(armhf). Deixo as duas opções a partir desta ajuda. No caso de também quererem testar PHP7, primeiro há que adicionar os repositórios:

PHP7 em Debian

echo 'deb http://packages.dotdeb.org jessie all' >> /etc/apt/sources.list
echo 'deb-src http://packages.dotdeb.org jessie all' >> /etc/apt/sources.list

Não esquecer a chave GnuPG

wget https://www.dotdeb.org/dotdeb.gpg
apt-key add dotdeb.gpg
rm dotdeb.gpg
apt-get update

PHP5/7 em Ubuntu

Agora sim, vamos ao PHP, conforme a versão que queiram instalar:

#opção PHP5
apt-get install libapache2-mod-php5
apt-get install php5-gd php5-json php5-curl
apt-get install php5-intl php5-mcrypt php5-imagick
apt-get install php5-pgsql
#opção PHP7
apt-get install libapache2-mod-php7.0
apt-get install php7.0-gd php7.0-json php7.0-curl php7.0-mbstring
apt-get install php7.0-intl php7.0-mcrypt php-imagick php7.0-xml php7.0-zip
apt-get install php-pgsql
#Restantes pacotes
apt-get install smbclient
#caso não esteja instalado o unzip
apt-get install unzip

Optimização (PHP5)

O Nextcloud, tal como o ownCloud pede algumas optimizações que deverão ser feitas, sob pena de impedir que alguns serviços extra, como as partilhas CIFS/SMB, funcionem correctamente. Primeiro há que instalar o php-apc/u que vai também instalar o modulo php5-apc/u. Provavelmente terão também de instalar o pacote memcached (ver aqui também)

apt-get install php5-apcu php5-memcached memcached

No meu caso, para que o APCu  funcionasse em Debian 8 correctamente, tive de ainda editar o ficheiro de configuração “pai” (retirado daqui) do PHP para que funcionasse correctamente, que é o abaixo, e não o que está dentro do apache (/etc/php5/apache2/php.ini):

nano /etc/php5/cli/php.ini

e depois acrescentar as linhas (depois de ;opcache.enable_cli=0):

;opcache.enable_cli=0
apc.enabled=1
apc.enable_cli=1

Depois há que dizer ao Nextcloud que o estamos a usar. Adicionar a seguinte linha ao config.php

nano /var/www/html/nextcloud/config/config.php
'memcache.local' => '\OC\Memcache\APCu',

Optimização (PHP7)

Para instalar a a versão do APCu para PHP7, basta instalar:

apt-get install php-apcu

Não esquecer que mais à frente temos de alterar o ficheiro de configuração do Nextcloud para que este use o APCu.

Aquando da instalação do PHP7, o pacote php7.0-opcache, é instalado, portanto, há que optimizar o ficheiro de configuração:

nano /etc/php/7.0/apache2/php.ini

e alterar:

[opcache]
 ; Determines if Zend OPCache is enabled
opcache.enable=1
opcache.enable_cli=1
opcache.memory_consumption=128
opcache.interned_strings_buffer=8
opcache.max_accelerated_files=10000
opcache.revalidate_freq=1
opcache.save_comments=1

Instalar o Nextcloud

Para instalar o Nextcloud basei-me nas minhas instalações anteriores do ownCloud, mas também obviamente na documentação oficial disponível aqui.

Depois é descarregar o último Nextcloud (ver o link em https://nextcloud.com/install/#instructions-server, na opção Download > Get Nextcloud Server > Download):

wget https://download.nextcloud.com/server/releases/nextcloud-12.0.0.zip

Descomprimir:

unzip nextcloud-12.0.0.zip

Mover para a pasta /var/www/html:

#debian8/xenial
mv nextcloud /var/www/html/

E dar as devidas permissões:

chown -R www-data:www-data /var/www/html/nextcloud/

 A seguir há que verificar se a pasta do Nextcloud já tem o ficheiro .htaccess (ls -al), senão, há que o criar:

#debian8/xenial
cd /var/www/html/nextcloud
ls -al
touch .htaccess
chown www-data:www-data .htaccess

Agora activar os dois seguintes módulos que irão ser necessários:

a2enmod rewrite
a2enmod headers
a2enmod env
a2enmod dir
a2enmod mime
a2enmod setenvif
a2enmod ssl
a2ensite default-ssl

Reiniciar o servidor apache:

service apache2 restart

Agora é só aceder por http, colocar as configurações (utilizador, base de dados, etc) que criaram no phpPgAdmin e criar o vosso utilizador de Administração.

http://10.0.0.25/nextcloud

Optimização (Nextcloud)

Memory Limit

Convém igualmente aceder ao log do apache em /var/log/apache2/error.log e verificar se existe algum erro do tipo:

[Wed Sep 02 14:34:20.826082 2015] [:error] [pid 16501] [client 192.168.1.x:59750] PHP Fatal error:  Allowed memory size of 13421772

Se sim, aceder ao php.ini e alterar as definições para, por exemplo:

#debian8/xenial

#php5
nano /etc/php5/apache2/php.ini
#php7
nano /etc/php/7.0/apache2/php.ini

E alterar para um valor que a vossa ram permita:

memory_limit = 2048M

NOTA: No caso do Raspberry Pi2/3 que tem 512Mb/1Gb de ram, colocar 384Mb/768Mb, e no caso do Orange Pi Zero, a minha versão é a de 265Mb, logo não deverá ultrapassar os 192Mb.

Aconselho vivamente a aumentar o valor exponencialmente acima dos 10 utilizadores.

APCu

Como disse acima, é preciso dizer ao Nexcloud para usar a cache de memória APCu. Portanto editar ficheiro:

nano /var/www/html/nextcloud/config/config.php

E adicionar na configuração do Nextcloud:

'memcache.local' => '\OC\Memcache\APCu',

Tamanho dos uploads

O PHP per sí limita o tamanho dos uploads, mas o máximo por defeito é de 2GB, portanto há que ter algum cuidado na gestão de alguns ficheiros. No entanto estou a testar a alteração para 4GB. Para definir os máximos aconselho a alteração dos seguintes valores no php.ini:

#php5
nano /etc/php5/apache2/php.ini
#php7
nano /etc/php/7.0/apache2/php.ini

e descomentar/activar a opção e aproveitar para alterar o tamanho dos uploads para o Nextcloud:

always_populate_raw_post_data = -1
file_uploads = On
upload_max_filesize = 4096M
post_max_size = 4096M

Manutenção / Actualização

Uma das coisas mais importantes que deve ser feita para que seja mais fácil actualizar e manter versões do quer do Nextcloud, quer do ownCloud é retirar a pasta /data (dos dados dos utilizadores) para um sítio diferente. Desta forma tem a pasta /var/www/html/owncloud sempre “livre” para trabalhar, e em caso de necessidade de reinstalação, não há necessidade de andar a mover ficheiros.

Uma das hipóteses que tenho visto bastante é mover a pasta /data para dentro da /var, ficando assim atrás do acesso web, mas ao mesmo tempo a mão e fácil de encontrar.

ATENÇAO: Este passo deve ser dado logo a seguir a instalação, pode ser feito posteriormente, mas com cautela, e com o Nextcloud em modo manutenção e todos os serviços parados.

#debian8
nano /var/www/html/nextcloud/config/config.php

Adicionar  alinha, logo no início:

'maintenance' => true,

Depois parar os serviços e mover:

#debian8
service apache2 stop
service postgresql stop
mv /var/www/html/nextcloud/data /var/

Depois da pasta movida, há que reconfigurar, quer as permissões da nova pasta, quer as configurações do Nextcloud.

#debian8
chown -R www-data:www-data /var/data/
nano /var/www/html/nextcloud/config/config.php

E redefinir a pasta em:

 'datadirectory' => '/var/data/',

O objectivo agora é actualizar para a ultima versão, neste caso a 9. Descarregar a ultima versão e descomprimir:

wget https://download.nextcloud.com/server/releases/nextcloud-10.0.1.zip
unzip nextcloud-10.0.1.zip

Antes de movermos para a pasta principal que estamos a usar, aconselho sempre a renomear/mover a pasta antiga para algo como nextcloud_old. Para além disso vamos precisar do ficheiro config.php que mexemos a pouco.

#debian8
cd /var/www/html/
mv nextcloud nextcloud_old

Agora sim podemos voltar a raiz e mover a nova versão para a pasta Nextcloud.

#debian8
cd \
mv nextcloud /var/www/html/

Agora, não esquecer de recuperar para esta nova pasta as nossas configurações (-avr permite ver o que é que está a copiar):

cp -avr nextcloud_old/config/config.php nextcloud/config/

Agora há que remover o Nextcloud do modo de manutenção e arrancar o Apache e o PostGreSQL.

nano /var/www/html/nextcloud/config/config.php
'maintenance' => false,
service postgresql start
service apache2 start

Agora é só aceder a vossa página do Nextcloud e correr o script de actualização (e rezar para que tudo corra bem). Comigo no rasp, foi limpinho, limpinho!

Configurar correctamente o CronJob

Para que o cron ocupe menos recursos, o melhor é mesmo usar um cron do sistema. Na administração, em vez de estar seleccionado em modo AJAX, escolher a opção Cron. De seguida listar o que está configurado no crontab e verificar se a ultima linha tem alguma coisa.

crontab -u www-data -l

Se nada estiver na ultima linha, efectuar a seguinte alteração:

crontab -u www-data -e

E adicionar a linha, onde 15 é minutos (de 15 em 15 minutos):

#debian8
*/15  *  *  *  * php -f /var/www/html/nextcloud/cron.php > /dev/null 2>&1

Configurar acessos externos

Para que se possa aceder a partir de um acesso externo, é necessário configurar o Nextcloud para que ele o permita. Aceder a:

#debian8
nano /var/www/html/nextcloud/config/config.php

E dentro dos trusted_domains, acrescentar cada um dos domínios, ou redireccionamentos configurados:

'trusted_domains' =>
 array (
 0 => '10.0.0.25',
 1 => 'mycloud.no-ip.info',
 2 => 'cloud.mydomain.net',
 ),

Configurar acessos SAMBA/CIFS do Nextcloud (PHP5)

Em primeiro lugar, para que o Nextcloud consiga aceder a partilhas windows ou samba, o cliente SMB tem de ser instalado. Há um pacote que melhora consideravelmente a performance do acesso SAMBA/CIFS que não está no repositório oficial do debian. Há que então adicionar o repositório do OC e instalar o smbclient e o novo pacote:

PS: pacote ainda não disponível para quaisquer dos Raspberry Pi, o que é pena.

#debian8
echo 'deb http://download.opensuse.org/repositories/isv:/ownCloud:/community:/8.1/Debian_8.0/ /' > /etc/apt/sources.list.d/php5-libsmbclient.list wget http://download.opensuse.org/repositories/isv:/ownCloud:/community:/8.1//Debian_8.0/Release.key apt-key add - < Release.key
wget http://download.opensuse.org/repositories/isv:ownCloud:community:8.1/Debian_8.0/Release.key
apt-key add - < Release.key
#debian7/8
apt-get update
apt-get install smbclient php5-libsmbclient

A partir daqui as opções de acessos aos armazenamentos externos dentro de “Personal” e “Admin” passam a ter disponíveis as opções “SMB / CIFS” e “SMB / CIFS using OC login“. A configuração que consegui que funcionasse num ambiente Windows Server 2008 foi a de alterar o meu username windows para algo mais linux frendly e colocar as seguintes opções:

Folder name: Nome que se deseja dar à pasta
Host: IP do servidor SMB/CIFS ('10.0.0.5')
Share: caminho até à pasta do utilizador no domínio (sem o IP, ex: "/data/users/adrianoafonso") ou apenas "/"
Remote subfolder: caminho da partilha
Domain: Nome de domínio, se aplicável
Username: nome de utilizador do domínio
Password: password do utilizador no domínio

Dados do user Nextcloud num disco ecterno (ext4)

Obviamente a solução de colocar os dados num disco NTFS, que podem ver no passo seguinte,  é util para utilizadores que queiram, em algum momento, e por alguma razão, desligar o sistema e ligar o disco a uma maquina com M$ Windows e ter imediatamente acesso aos ficheiros. Ora, se não for esse o caso, estamos a basicamente a “estragar” o nosso Pi com processamento desnecessário, e a comprometer o desempenho. Obviamente a escrita e leitura em ext4 (formato que se aconselha para estas soluções Pi) é muito mais rápida e eficaz, e o desempenho até se nota em upload (velocidade do Pi a colocar um ficheiro na cloud).

Se precisam de formatar o disco em ext4, sigam este tutorial. Para o fazer vou começar por ligar um disco externo já formatado em ext4 ao Pi, e seguir os procedimentos habituais, de primeiro saber a UUID do disco:

blkid

O vosso disco deverá estar identificado como /dev/sda1. Se sim, copiar já o UUID, que vai ser preciso mais à frente. Agora ir à pasta /media e criar a pasta com o nome do disco (aconselho para ser mais fácil a identificação).

mkdir /media/<nome_do_disco>

Para montar o disco definitivamente (sempre que o sistema for reiniciado, ele esteja montado), é necessário ir ao fstab e inserir manualmente na ultima linha:

nano /etc/fstab

UUID=[UUID_copiado_anteriormente] /media/<nome_do_disco> ext4 defaults 0 2

Reiniciar o sistema e em princípio o disco estará montado. Por fim só falta dar permissões ao disco:

chown -R www-data:www-data /media/<nomedodisco>/data
chmod 770 /media/<nome_do_disco>/data

Reiniciem e verifiquem se tudo está como previsto. Agora há que mover a pasta data para o respectivo disco que se acabou de montar:

#debian8
mv /var/www/html/nextcloud/data/ /media/<disco>/

A seguir, basta voltar à configuração do nextcloud, e agora apontar para a localização da nova pasta:

#debian8
nano /var/www/html/nextcloud/config/config.php
'datadirectory' => '/media/<disco>/data',

Depois há que (re)atribuir as permissões correctas à pasta do nextcloud:

chown -R www-data:www-data /media/<nomedodisco>/data
chmod 770 /media/<nome_do_disco>/data

Arrancar o Apache e o PostGreSQL, e está feito!

service apache2 start
service postgresql start

Testem de imediato, colocando uma pasta e vejam se sincroniza. O meu leva algum tempo, mas sincroniza lindamente.

Dados do user Nextcloud num disco externo USB (NTFS)

Nas implementações com Raspberry Pi/OrangePi, visto haver pouco espaço no disco principal, é comum passar a pasta de sincronização para outro disco. Convém em primeiro lugar verificar se os mounts estão no sítio certo. Se o mount for automático, cuidado que o raspbmc pode mudar o os códigos (sda/sdb) dos discos ao reiniciar/ligar outro disco. Convém verificar sempre com o comando blkid. Primeiro que tudo há que parar o apache e o servidor de base dados.

service apache2 stop
service postgresql stop

Como no meu caso tenho uma pasta no apache e uma pasta também no disco externo para o Nextcloud, pretende-se mover a pasta para o local respectivo. Na primeira instalação, movi toda a pasta do Nextcloud como o tutorial recomendava, mas como o disco está em NTFS e posso precisar dele ainda neste formato, deu-me alguns problemas com as permissões e até que o servidor rebentou. No entanto inventei outra solução, à qual já fiz mais uns upgrades. Depois de instalar o Nextcloud e criar o meu utilizador, movi a pasta dos dados para o disco externo.

Seguido este tutorial para o fazer, há que começar por adicionar um disco. Primeiro há que ver se ele está ligado:

blkid

Isto vai listar os discos estão ligados. Aproveitem para copiar já o UUID, vão precisar dele mais à frente. Cuidado que se o rasp não tiver power suficiente o disco pode simplesmente não arrancar e obviamente não ser detectado.  O /dev/sda1 deverá ser o nosso disco. Depois confirmar se a pasta existe no /media/:

cd /media/
ls

Se não estiver lá, é porque provavelmente não está montado. Portanto há que criar a pasta:

mkdir /media/<nome_do_disco>

Em muitos casos o pacote de reconhecimento de partições NTFS não está instalado por defeito, há que o fazer através:

apt-get install ntfs-3g

E a seguir montar o disco:

mount -t ntfs-3g -o uid=0,gid=0 /dev/sda1 /media/<nome_do_disco>

Nota que aqui as permissões são dadas ao root, partindo do princípio que estejam a usar este utilizador. E não esquecer de dar as permissões devidas ao mount:

chmod 770 /media/<nome_do_disco>

Para garantir que o mount seja mantido depois de reiniciar, o melhor adicionar a seguinte linha ao fstab. Primeiro aceder ao fstab:

nano /etc/fstab

Depois adicionar a seguinte linha, com o UUID que copiaram anteriormente::

UUID=<uuid_do_disco> /media/<nome_do_disco> ntfs-3g noatime,noatime,auto,users,permissions
 0 0

Reiniciem e verifiquem se tudo está como previsto. Agora há que mover a pasta data para o respectivo disco que se acabou de montar:

#debian8
mv /var/www/html/nextcloud/data/ /media/<disco>/

A seguir, basta voltar à configuração do nextcloud, e agora apontar para a localização da nova pasta:

#debian8
nano /var/www/html/nextcloud/config/config.php
'datadirectory' => '/media/<disco>/data',

Depois há que (re)atribuir as permissões correctas à pasta do nextcloud:

chown -R www-data:www-data /media/<nomedodisco>/data
chmod 770 /media/<nome_do_disco>/data

Arrancar o Apache e o PostGreSQL, e está feito!

service apache2 start
service postgresql start

Testem de imediato, colocando uma pasta e vejam se sincroniza. O meu leva algum tempo, mas sincroniza lindamente.

Adicionar disco (interno/externo) à directoria do user

Em primeiro lugar tenho que agradecer ao Sílvio André por esta dica, que me deu bastante jeito numa implementação caseira numa máquina de um cliente.

Se o disco já estiver ligado na máquina há que começar por o montar devidamente. Primeiro há que ver se ele está ligado:

blkid

Isto vai listar os discos estão ligados. Aproveitem para copiar já o UUID, vão precisar dele mais à frente.  O /dev/sda1 deverá ser o nosso disco. Depois confirmar se a pasta existe no /media/:

cd /media/
ls

Se não estiver lá, é porque provavelmente não está automaticamente montado. Portanto há que criar a pasta:

mkdir /media/<nome_do_disco>

Em muitos casos o pacote de reconhecimento de partições NTFS não está instalado por defeito, há que o fazer através:

apt-get install ntfs-3g

E não esquecer de dar as permissões devidas ao mount:

chmod 775 /media/<nome_do_disco>

Para garantir que o mount seja mantido depois de reiniciar, o melhor adicionar a seguinte linha ao fstab. Primeiro aceder ao fstab:

nano /etc/fstab

Depois adicionar a seguinte linha, com o UUID que copiaram anteriormente:

UUID=<uuid_do_disco> /media/<nome_do_disco> ntfs-3g noatime 0 0

Outra configuração que poderá ser válida é a seguinte:

UUID=<uuid_do_disco> /media/<nome_do_disco> ntfs defaults,rw,group=33 0 0

Em que aqui aqui são os parâmetros de acesso, por exemplo, “rw”, indica que o disco permitirá a escrita e group=33, especifica que o disco está acessível ao apache. Reiniciem e verifiquem se tudo está como previsto.

De seguida há que aceder à interface do Nextcloud > Apps (canto supeior direito) > procurar e activar a app “External storage support“.

Para dar permissão de acesso a todos os utilizadores/grupo definido terem acesso ao disco, ir á página “Admin” e efectuar as seguintes configurações:

Folder name: Nome que se deseja dar à pasta
External storage: Local
Authentication: None
Configuration: caminho configurado em /media/<nome_do_disco>
Available for: Especificar o grupo que irá ter acesso ao disco

Samba

Neste servidor tive a necessidade de ter uma pasta partilhada (com acesso geral) na rede interna, para depois ter acesso à mesma externamente a partir do Nextcloud. Segui os passos do manual oficial do Debian com uma ajuda daqui. O primeiro passo, é obviamente, instalar os pacotes do samba:

apt-get install samba

De seguida guardar o ficheiro original e criar um novo ficheiro de configuração:

mv /etc/samba/smb.conf /etc/samba/smb.bak
nano /etc/samba/smb.conf

Com as seguintes alterações:

[global]
   workgroup = [rede a ser encontrada]
   wins support = yes
   security = user
   map to guest = Bad User
   share modes = yes

[homes]
 comment = Home Directories
 browsable = no
 read only = no
 create mode = 0750

[share]
 path = /media/share/
 public = yes
 writable = yes
 comment = smb share
 printable = no
 guest ok = yes

Com esta configuração vamos obter uma partilha com o nome “share” aberta a todos os utilizadores com permissões de escrita. No entanto, antes de por tudo a funcionar, convém criar a pasta e dar permissões de escrita a essa mesma pasta:

mkdir /media/share
chmod 777 /media/share

Por fim, reiniciar o samba

/etc/init.d/samba restart

Não esquecer que a cada alteração efectuada, o samba deve ser igualmente reiniciado.

Cópia de segurança programada às 23:00

Muitos de vós já passaram por situações complicadas, desde um disco que morreu, a mais recentemente os ataques de ransonware. Nunca é demais cópias de segurança, e portanto, decidi fazer uma que envie para dentro do nextCloud, e depois seja distruibuida por este por todas as máquinas cliente. Em primeiro criar o script:

nano /usr/local/sbin/backupdados.sh

Depois inserir o seguinte código:

#backupdados.sh
#!/bin/sh
find /var/tmp/ -type f -mtime +7 -exec rm {} +
find /media/Hardrive/Backup/ -type f -mtime +1 -exec rm {} +
tar -zcvf /media/Hardrive/Backup/backup$(date +%Y%m%d-%H%M%S).tar.gz /media/Hardrive/Partilha/
tar -jcvf /media/Hardrive/Backup/backup$(date +%Y%m%d-%H%M%S).tar.bz2 /media/Hardrive/Partilha/
find /media/Hardrive/Backup/ -type f -user root -exec chown www-data:www-data {} + 2>>logfile

O que este código vai fazer é o seguinte:

  • Limpar a pasta temporária com mais de 7 dias
  • Apagar todos os ficheiros com mais de 1 dia (do dia anterior) da pasta Backup
  • Criar um tar.gz/tar.bz2 da pasta Partilha com o nome “backupdata-hora.tar.gz/tar.bz2” no nome do ficheiro e guardar na pasta Backup
    • Os dois ficheiros tar.gz e tar.bz2 servem apenas para testar as compressões, depois comentem com # no inicio da linha
  • Atribuir permissões www-data para que depois o Nextcloud possa apagar os ficheiros que estão na pasta

Por fim há que corriguir as permissões ao ficheiro

chmod +x /usr/local/sbin/backupdados.sh

E criar um CronJob para que o script seja corrido àquela determinada hora:

crontab -e

E adicionar na ultima linha:

# Backup dos Dados @ 23:00
00 23 * * * bash /usr/local/sbin/backupdados.sh > /dev/null 2>&1

Caso necessário, reiniciar o serviço do Cron:

service cron restart

2 Comment

  1. Muito bom mas em certos momentos do tutorial acabei ficando confuso, por favor, gostaria de entrar em contato parar tirar algumas duvidas para um trabalho semelhante! Desde ja obrigado.

  2. Anderson Brazil Windows 7 Google Chrome 58.0.3029.110 says:

    Muito bom post.
    Tiago veja aqui se resolve p vc: https://ownyourbits.com/2017/02/13/nextcloud-ready-raspberry-pi-image/

Deixar uma resposta

three × 2 =