Criar um servidor Nextcloud (Debian 8/9/10/11/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:

• installing-nextcloud-on-ubuntu-16-04-lts-with-redis-apcu-ssl-apache

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). Também estou a utilizar um novo servidor VMWare ESXi 6.5. Aproveito para deixar já aqui uma dica, em muitas distribuições estão disponíveis os pacotes Open VM Tool que permitem a interacção do host directamente com o VMWare ESXi. Isto permite algumas funcionalidades extra de gestão, configuração e administração dos hosts. Em Debian, depois da instalação, basta fazer:

apt-get install open-vm-tools

Raspberry Pi v2/3/4

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

• Rasp V3 > Raspberry Pi OS Lite: https://www.raspberrypi.org/downloads/raspbian/ [pi|raspberry]
• Rasp V2/3 ubuntu-16.04.2-preinstalled-server-armhf+raspi2.img.xz
• Rasp V2: raspbian-ua-netinst (raspbian-ua-netinst-v1.x.x.img.bz2)

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

Estou 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.

Locals

É sempre bom, antes de iniciar a configuração do servidor, dizer geograficamente onde é que ele está, para que as horas batam certo. Pessoalmente apenas reconfiguro a Time Zone (tzdata), pois prefiro que o SO esteja sempre em inglês.

dpkg-reconfigure locales
dpkg-reconfigure tzdata

Configuração de rede (Debian)

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 é aplicável 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/9 é provável que encontrem algum texto novo, colocar a configuração estática debaixo de: “source-directory /etc/network/interfaces.d”.

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

NOTA: Caso o servidor SSH já esteja instalado (como no caso do Raspbian), o melhor é desinstalar [apt-get purge openssh-server] primeiro e voltar a instalar [apt-get install openssh-server], para que seja reconfigurado com o novo 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. Correr o seguinte comando para actualizar o hostname

/etc/init.d/hostname.sh start

Por fim, reiniciar o sistema porque é a melhor maneira de garantir que o nome fique realmente atribuído.

Configuração de rede (Ubuntu)

IP Fixo+DNS’s

Em Ubuntu indicam-vos para utilizar o nmtui, esqueçam… Se estão a usar a distribuição 16.04.2 LTS e que venha instalado o pacote cloud-init, aconselho a sua remoção. A mim deu-me vários problemas em que não conseguia ter a placa de rede a funcionar direito (ora tinha DHCP com fixo definido, ora perdia ip fixo, e depois retorna sempre erros no ifdown/up).

apt-get remove cloud-init
apt-get remove --auto-remove cloud-init
apt-get purge cloud-init
apt-get purge --auto-remove cloud-init
sudo rm -rf /etc/cloud/; sudo rm -rf /var/lib/cloud/

De notar que a configuração de rede é um pouco diferente. Depois de desinstalar o cloud-init, a configuração de rede já pode ser feita em:

nano /etc/network/interfaces

No entanto a configuração de DNS deverá ser incluída aqui na seguinte forma:

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

dns-nameservers 208.67.222.222 8.8.8.8 208.67.220.220 8.8.4.4

NOTA: Enquanto que em Debian conseguimos ter dois IP’s definidos, em ubuntu tive de comentar e descomentar consoante a necessidade para que tudo funcionasse direito.

A seguir convém sempre reiniciar a placa de rede para ela poder assumir o IP atribuído:

ifdown eth0
ifup eth0

Hostname

Praticamente igual a Debian, basta editar os ficheiros, mas o mesmo se aplica se o servidor SSH estiver já instalado:

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).

Preparar o servidor SSH

Debian8/9/10

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 secção de “Authentication” para:

LoginGraceTime 2m
PermitRootLogin yes
#StrictModes yes
#MaxAuthTries 6
MaxSessions 5

E não esquecer depois de ativar o serviço no arranque e reiniciar o servidor de SSH

update-rc.d ssh enable
service ssh restart

Activar acesso SSH em Ubuntu/Debian

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 e a conta root foi unlocked. 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/11.9)

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;

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
exit

\q permite sair do servidor postgres, e exit, voltar a root!

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

#debian8/9/10/xenial
psql --version
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
nano /etc/postgresql/11/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

Não esquecer de reiniciar o PostgreSQL:

service postgresql restart

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/9/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/9
nano /etc/apache2/conf-enabled/phppgadmin.conf

E descomentar a linha que diz:

#debian8/9
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 acontece 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 8

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

Pacotes necessários PHP5/7 em Debian 9/10/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|Debian9
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
#opção PHP7.3|Debian10
apt-get install libapache2-mod-php7.3
apt-get install php7.3-gd php7.3-json php7.3-curl php7.3-mbstring
apt-get install php7.3-intl php-imagick php7.3-xml php7.3-zip php-fpm
apt-get install php-pgsql
#opção PHP7.3|Debian11
apt-get install php-bcmath libgmp3-dev

NOTICE: Not enabling PHP 7.3 FPM by default.
NOTICE: To enable PHP 7.3 FPM in Apache2 do:
NOTICE: a2enmod proxy_fcgi setenvif
NOTICE: a2enconf php7.3-fpm
NOTICE: You are seeing this message because you have apache2 package installed.
#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
nano /etc/php/7.3/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
# NOTA: Também podem usar o link directo para a ultima versão
wget https://download.nextcloud.com/server/releases/latest.zip

Descomprimir:

unzip nextcloud-12.0.0.zip

Mover para a pasta /var/www/html:

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:

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/9/10/xenial

#php5
nano /etc/php5/apache2/php.ini
#php7
nano /etc/php/7.0/apache2/php.ini
nano /etc/php/7.3/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
nano /etc/php/7.3/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/9
nano /var/www/html/nextcloud/config/config.php

Adicionar a linha, logo no início:

'maintenance' => true,

Depois parar os serviços e mover:

#debian8/9
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/9
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:

#zip
wget https://download.nextcloud.com/server/releases/nextcloud-10.0.1.zip
unzip nextcloud-10.0.1.zip
#tar
wget https://download.nextcloud.com/server/releases/nextcl                                                      oud-16.0.7.tar.bz2
tar jxf  nextcloud-16.0.7.tar.bz2

wget https://download.nextcloud.com/server/releases/nextcl                                                      oud-17.0.2.tar.bz2
tar jxf  nextcloud-17.0.2.tar.bz2 

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/9
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/9
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/9
*/15  *  *  *  * php -f /var/www/html/nextcloud/cron.php > /dev/null 2>&1

Notas/Bugs

Na criação de utilizadores detectei um bug que está a afectar varias versões. Aquando da criação, se a password for demasiado simples (sem letras, numeros e caracteres) o Nextcloud dá um erro e Apache acaba mesmo por ficar pendurado. Este bug está reportado aqui. Solução: Em Security, definir/activar:

• Minimal length [8]
• Forbid common passwords
• Enforce upper and lower case characters
• Enforce numeric characters
• Enforce special characters

Configurar acessos externos

ownCloud/Nextcloud

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

#debian8/9/10
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',
 ),

no-ip.org

Muitos de nós, mesmo em ambiente empresarial (eu não devia dizer isto :P) usamos soluções Dynamic DNS para solucionar o problema do IP fixo (que normalmente não temos). Normalmente, pela facilidade e reconhecimento (a menos quando a Microsoft decide fazer asneiras) uso no-ip. Para usar o actualizador automático, temos de primeiros instalar:

apt-get install build-essential

Depois segui o tutorial oficial que está aqui:

cd /usr/local/src/
wget http://www.no-ip.com/client/linux/noip-duc-linux.tar.gz
tar xf noip-duc-linux.tar.gz
cd noip-2.1.9-1/
make install

Durante a instalação ser-vos-ão pedidas as credenciais, é só seguir os passos. Por fim, correr o comando

/usr/local/bin/noip2

No entanto insto não faz com que ele inicie automaticamente. Para isso é preciso criar um script no init.d para que ele corra cada vez que se reinicie. De notar que dei o nome do script igual ao programa.

cd /etc/init.d/
nano noip2

Este foi o script que funcionou, depois de ter utilizado o BEGIN INIT INFO daqui e o resto daqui (mais umas tentativas e erro):

#! /bin/sh
# /etc/init.d/noip2

# Supplied by no-ip.com
# Modified for Debian GNU/Linux by Eivind L. Rygge <eivind@rygge.org>
# Updated by David Courtney to not use pidfile 130130 for Debian 6.
# Updated again by David Courtney to "LSBize" the script for Debian 7.

### BEGIN INIT INFO
# Provides:          noip2
# Required-Start:    $remote_fs $syslog
# Required-Stop:     $remote_fs $syslog
# Default-Start:     2 3 4 5
# Default-Stop:      0 1 6
# Short-Description: Start daemon at boot time
# Description:       Enable service provided by daemon.
### END INIT INFO

# . /etc/rc.d/init.d/functions  # uncomment/modify for your killproc

DAEMON=/usr/local/bin/noip2
NAME=noip2

test -x $DAEMON || exit 0

case "$1" in
    start)
    echo -n "Starting dynamic address update: "
    start-stop-daemon --start --exec $DAEMON
    echo "noip2."
    ;;
    stop)
    echo -n "Shutting down dynamic address update:"
    start-stop-daemon --stop --oknodo --retry 30 --exec $DAEMON
    echo "noip2."
    ;;

    restart)
    echo -n "Restarting dynamic address update: "
    start-stop-daemon --stop --oknodo --retry 30 --exec $DAEMON
    start-stop-daemon --start --exec $DAEMON
    echo "noip2."
    ;;

    *)
    echo "Usage: $0 {start|stop|restart}"
    exit 1
esac
exit 0

A seguir o script deverá ser tornado um executável/ com permissões de execução e também de seguida efectuar o registo no startup:

chmod 755 /etc/init.d/noip2
chown root /usr/local/etc/no-ip2.conf
update-rc.d noip2 defaults

Por fim testar com start e stop e verificar se corre como previsto e não retorna erros.

/etc/init.d/noip2 start
/etc/init.d/noip2 stop

Caso seja necessário reconfigurar o no-ip, basta correr o seguinte comando:

/usr/local/bin/noip2 -C

Certificado válido HTTPS/SSL (Let’s Encrypt)

Uma das grandes preocupações dos utilizadores destas soluções (especialmente nos clientes onde tenho instalado) é exactamente a preocupação com a segurança. Tecnicamente, a utilização do default_ssl é suficientemente segura, mas tona-se um pouco “chato” o adicionar a excepção de segurança, e provoca desconfiança no utilizador. Para resolver este problema, especialmente nas implementações caseiras/in-house foi criado o Let’s Encrypt, uma forma livre, segura, gratuita e simples de ter um certificado SSL.

Para iniciar o processo, copiado deste tutorial que aconselho a visita, decidi usar a mesma pasta onde já tenho o no-ip instalado (para não ter as coisas espalhadas). Vou logo descarregar o ficheiro e iniciar a instalação:

#ubuntu 
apt-get install letsencrypt python-pip 
#debian 
cd /usr/local/bin/ wget https://dl.eff.org/certbot-auto && chmod a+x certbot-auto

A seguir correr o script:

sudo ./certbot-auto --apache --agree-tos --rsa-key-size 4096 --email user@domain.org --redirect -d nc.domain.org

<NOTA>
#Ubuntu: Caso obtenham o erro seguinte, ainda não sei resolver!:

Command /root/.local/share/letsencrypt/bin/python2.7 - setuptools pkg_resources pip wheel failed with error code 2

</NOTA>

Onde as opções correspondem às seguintes:

--apache usa o plugin do Apache para configurar e integrar completamente com a configuração existente.
--agree-tos pre-aceita o TOS, prevenindo a questão durante a instalação.
--rsa-key-size define o tamanho (e igualmente a qualidade da segurança) da chave RSA. Por defeito é 20148.
--email a conta de correio electrónico que ficará associada ao certificado e igualmente utilizado Let’s Encrypt para os avisos.
--redirect irá criar tanto a a configuração de virtualhost SSL como também os redireccionamentos HTTP > HTTPS (80 para a 443)
-d é o domínio a ser configurado

É normal durante o correr do script que sejam instalado alguns pacotes em falta que irão ser necessários para o normal funcionamento do bot do Let’s Encrypt.

A partir deste ponto o script irá tratar de tudo por nós. No entanto, para que tudo fique o mais correcto possível é aconselhável realizar as seguintes alterações no ficheiro, depois da configuração do ServerName:

nano /etc/apache2/sites-available/000-default-le-ssl.conf

<Directory /var/www/html/>
 # Options +FollowSymlinks
 # AllowOverride All

<IfModule mod_dav.c>
 Dav off
 </IfModule>

SetEnv HOME /var/www/html
 SetEnv HTTP_HOME /var/www/html
 </Directory>

<IfModule mod_headers.c>
 Header always set Strict-Transport-Security "max-age=15768000; preload"
 </IfModule>

Como este certificado é gratuito, irá expirar dentro de 90 dias. Para que seja renovado automáticamente, basta adicionar um cronjob a apontar para o bot (a utilização da mesma pasta do no-ip agora dá jeito, tendo tudo arrumadinho). Abrir o crontab do root, e adicionar a linha mais abaixo, depois dos comentários.

crontab -e
0 0 * * 0 /usr/local/bin/certbot-auto renew

Internal Redirects

Uma das coisas que “não gosto” de ver, é a página de boas vindas do apache quando me engano e não escrevo o URL todo. Especialmente, para o cliente deve ser mais transparente possível. Vários já me perguntaram porque é que não coloco o Nextcloud na raiz, e a razão é simples, é que normalmente tenho mais que uma coisa acessível (logo, distribuído pelas respectivas pastas). Para que o acesso externo seja feito de modo transparente, adoptei a seguinte estratégia. Primeiro, vou dizer ao apache só para ler ficheiros index.php no inicio das pastas.

nano /etc/apache2/mods-enabled/dir.conf

E alterar apenas para:

<IfModule mod_dir.c>
 DirectoryIndex index.php
</IfModule>

Depois, na raiz (prevendo que possa aceder às restantes pastas no futuro), defino um .htaccess que reencaminha para a pasta que quero quando o acesso é externo.

touch .htaccess 
chown www-data:www-data .htaccess
nano .htaccess

E introduzir

<IfModule mod_rewrite.c>
RewriteEngine On
 RewriteCond %{HTTP_HOST} !^http://cloud.no-ip.org$ [NC]
 RewriteRule ^(.*)$ https://cloud.no-ip.org/nextcloud/ [L,R=301]
</IfModule>

Redirect 301 / /nextcloud

//Change default directory page
DirectoryIndex /nextcloud/

//Prevent viewing of .htaccess file
<Files .htaccess>
order allow,deny
deny from all
</Files>

//Prevent directory listings
Options All -Indexes

Por fim criar um ficheiro index.php:

nano /var/www/html/index.php

E introduzir o reencaminhamento, garantido o mesmo:

<?php header("Location: nextcloud/");?>

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 externo (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 -R 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/9 
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/9 
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.

EXTRA: Como entrar no Pi/Server, quando o disco rígido morre!

Bem, não foi exactamente isso que me aconteceu, mas sim uma alteração de disco, que me esqueci de “desmontar” no fstab. Se o desligarem um disco montado nos procedimentos anteriores, o server vai entrar em erro, não vai arrancar e não vão conseguir fazer nada, nem sequer aceder por SSH.

"Cannot open access to console, the root account is locked." 

A solução está nesta ligação, onde aprendem a montar o uSD e editar o fstab para conseguirem que ele arranque novamente.

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

Recuperação do Nextcloud depois de um SD Corrompido

Recentemente tive um problema com um cartão SD corrompido em que perdi toda a configuração e respectiva base de dados do Nextcloud no meu RaspberryPi. Sim, pode ser um pesadelo, não tivesse a equipa pensado numa solução que a mim me conseguiu resolver o problema em poucas horas. Depois de instalar tudo de novo (e aproveitei para passar tudo para Debian 9 na minha configuração pessoal) e reproduzir todas as configurações que tinha no anterior, sem passar a pasta data para o disco externo (mas já com ele montado), bastou-me fazer o seguinte:

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

Relembrar que na minha configuração a pasta data do Nextcloud está no disco externo, devidamente formatado com AINDA todos os dados que estavam na antiga cloud que perdi. Com estes comandos vamos listar as pastas que estão na pasta data e relembrar quais são os utilizadores que estavam configurados. Aproveitamos e atribuímos já as devidas permissões.

O próximo passo, e extremamente importante, é recriar TODOS esses utilizadores dentro do Nextcloud (antes de mudar qualquer caminho de pasta). Não importa se depois esta pasta data fica dentro da pasta do Apache ainda no SD, pois não as vamos usar! A seguir, parar o Apache, corrigir já a localização da pasta data no Nextcloud e correr o comando files:scan.

service apache2 stop
nano /var/www/html/nextcloud/config/config.php 
'datadirectory' => '/media/<disco>/data', 
cd /var/www/html/nextcloud/
sudo -u www-data php occ files:scan --all

Este comando, dependendo da quantidade de ficheiros, vai demorar bastante, mas irá reconstruir toda a base de dados com os ficheiros que estavam armazenados na pasta data que estava no meu disco externo. Este foi o resultado do comando, apenas 41min +/- depois!

 Starting scan for user 1 out of 3 (user.1)
 Starting scan for user 2 out of 3 (user.2)
 Starting scan for user 3 out of 3 (user.3)
 +---------+-------+--------------+
 | Folders | Files | Elapsed time |
 +---------+-------+--------------+
 | 2992    | 64930 | 00:40:59     |
 +---------+-------+--------------+

Convém agora arrancar o Apache, que foi parado para o servidor não estar ocupado com rigorosamente mais nada, nem haver a “tentação” de sincronizar algo que não devesse!

 service apache2 start

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 = [o grupo de trabalho a que vai pertencer]
  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