Seafile es un software de nube privada que proporciona funciones similares como Dropbox, mega.co.nz y otras, simplemente alojadas en su propio servidor. Seafile se basa en el lenguaje de programación Python y se publica con una licencia de código abierto para que pueda crear su propia nube privada y sea mucho más segura.
Seafile admite el cifrado para almacenar sus datos de forma segura. Para cifrar archivos en una biblioteca de almacenamiento, debe establecer una contraseña cuando crea la biblioteca. La contraseña no se almacenará en la nube de Seafile. Por lo tanto, incluso el administrador de los servidores no puede ver sus datos cifrados sin la contraseña.
En este tutorial, instalaré Seafile en CentOS 7 con el servidor web Nginx y MariaDB como servidor de base de datos.
Requisitos
- Servidor CentOS 7
- Privilegios de raíz
Paso 1:preparar CentOS para Seafile
Inicie sesión en el servidor centOS con su contraseña de root ssh.
ssh [email protected]
TYPE YOUR PASSWORD
Edite el archivo de configuración de SELinux con vim.
vim /etc/sysconfig/selinux
Reemplace el valor 'enforcing' con 'disabled'.
SELINUX=disabled
Guarde el archivo y salga del editor.
Reinicie el servidor para aplicar el cambio de la política de SELinux.
reboot
Espere a que se reinicie el servidor, luego vuelva a iniciar sesión en su servidor como usuario root.
Verifique el selinux con el siguiente comando:
getenforce
Debería ver 'Deshabilitado ' como resultado.
Paso 2:instalar las dependencias de Seafile
Seafile se basa en python, por lo que primero debemos instalar python para la instalación. Seafile es compatible con las bases de datos SQLite y MySQL/MariaDB. Usaré MariaDB como base de datos para Seafile aquí, ya que proporciona un mejor rendimiento que SQLite. Nginx se utiliza como proxy inverso para Seafile y Seahub.
En este paso, instalaremos varios paquetes de Python, MariaDB y Nginx. Comenzamos con la instalación del repositorio EPEL en nuestro servidor CentOS.
yum -y install epel-release
A continuación, instale los paquetes de python, MariaDB y Nginx.
yum -y install python-imaging MySQL-python python-simplejson python-setuptools mariadb mariadb-server nginx
Espere hasta que todos los paquetes estén instalados.
Paso 3:configurar MariaDB
En el paso 2, ya instalamos el servidor MariaDB, solo necesitamos iniciar el servicio y configurar la contraseña de root ahora.
Inicie MariaDB y configure la contraseña de root con los siguientes comandos:
systemctl start mariadb
mysql_secure_installation
Escriba su contraseña raíz.
Set root password? [Y/n] Y
New password:
Re-enter new password:
Remove anonymous users? [Y/n] Y
Disallow root login remotely? [Y/n] Y
Remove test database and access to it? [Y/n] Y
Reload privilege tables now? [Y/n] Y
La contraseña raíz de MariaDB está configurada y ahora podemos iniciar sesión en el shell mysql.
Aviso:el shell de la línea de comandos de MariaDB se llama mysql.
Crearemos 3 bases de datos para seafile:
- ccnet_db
- seafile_db
- seahub_db
Y crearemos un nuevo usuario 'seacloud ' con la contraseña 'tucontraseña '. ¡Reemplace su contraseña con una contraseña segura!
Inicie sesión en el shell mysql con el cliente mysql.
mysql -u root -p
TYPE YOUR PASSWORD
Ejecute las consultas mysql a continuación para crear las bases de datos y el usuario para la instalación del archivo marino.
create database ccnet_db character set = 'utf8';
create database seafile_db character set = 'utf8';
create database seahub_db character set = 'utf8';
create user [email protected] identified by 'yourpassword';
grant all privileges on ccnet_db.* to [email protected] identified by 'yourpassword';
grant all privileges on seafile_db.* to [email protected] identified by 'yourpassword';
grant all privileges on seahub_db.* to [email protected] identified by 'yourpassword';
flush privileges;
exit
Reemplace su contraseña en los comandos anteriores con su propia contraseña.
Paso 4:instalar Seafile
En este paso, instalaremos Seafile. Seafile se ejecutará con el usuario nginx para que podamos usar nginx como proxy inverso para los servicios seafile y seahub.
Instalaremos seafile bajo el usuario nginx en el directorio '/var/www/seafile', crearemos ese directorio y lo ingresaremos con cd.
mkdir -p /var/www/seafile
cd /var/www/seafile
Descargue Seafile con el comando wget y extraiga el archivo descargado.
wget https://bintray.com/artifact/download/seafile-org/seafile/seafile-server_6.0.5_x86-64.tar.gz
tar -xzvf seafile-server_6.0.5_x86-64.tar.gz
Cambie el nombre del directorio a 'seafile-server' y cambie a ese directorio.
mv seafile-server-6.0.5 seafile-server
cd seafile-server/
Ejecute el archivo 'setup-seafile-mysql.sh' para configurar la base de datos.
./setup-seafile-mysql.sh
Presione Entrar y se le pedirá información a continuación:
- nombre del servidor:usaré el nombre de host del servidor 'natsume '
- ip o dominio del servidor - dirección ip del servidor, en mi caso '192.168.1.115 '
- directorio de datos predeterminado:simplemente presione Entrar
- puerto predeterminado:presione Intro
- Ahora para la configuración de la base de datos, elija el número 2
Para la configuración de MySQL:
- usar host predeterminado - localhost
- puerto predeterminado:3306
- el usuario de mysql - 'seacloud '
- y la contraseña es 'tucontraseña '
- la base de datos de ccnet es 'ccnet_db '
- la base de datos seafile es 'seafile_db '
- la base de datos de seahub es 'seahub_db '
Presione enter y el script creará las tablas de la base de datos para el archivo marino.
Ahora podemos iniciar los servicios seafile y seahub.
./seafile.sh start
./seahub.sh start
Cuando se ejecute el archivo seahub.sh, se nos pedirá la configuración del administrador.
Escriba su correo electrónico y contraseña de administrador, luego se ejecutará el servicio seahub.
Seafile está instalado y ejecutándose ahora, podemos acceder a Seafile desde un navegador web con la IP del servidor en el puerto 8000 (en mi caso, 192.168.1.115:8000), pero no lo haremos ahora porque usaremos un proxy inverso para el servidor seafile y ejecutaremos seafile con un archivo de servicio systemd.
Por lo tanto, debemos detener el servicio seafile y seahub por ahora.
./seafile.sh stop
./seahub.sh stop
Paso 5:configurar el servicio Seafile y Seahub
Ejecutaremos seafile como usuario de nginx, por lo que debemos cambiar el propietario del directorio de instalación de seafile y el directorio seahub_cache al usuario de nginx:
cd /var/www/
chown -R nginx:nginx *
chown -R nginx:nginx /tmp/seahub_cache
A continuación, vaya al directorio systemd y cree un archivo seafile.service con vim:
cd /etc/systemd/system/
vim seafile.service
Pegue la configuración del servicio Seafile a continuación:
[Unit]
Description=Seafile Server
Before=seahub.service
After=network.target mariadb.service
[Service]
Type=oneshot
ExecStart=/var/www/seafile/seafile-server/seafile.sh start
ExecStop=/var/www/seafile/seafile-server/seafile.sh stop
RemainAfterExit=yes
User=nginx
Group=nginx
[Install]
WantedBy=multi-user.target
Guardar y salir.
Ahora cree un nuevo archivo seahub.service.
vim seahub.service
Y pegue la configuración a continuación.
[Unit]
Description=Seafile Hub
After=network.target seafile.target mariadb.service
[Service]
Type=oneshot
ExecStart=/var/www/seafile/seafile-server/seahub.sh start-fastcgi
ExecStop=/var/www/seafile/seafile-server/seahub.sh stop
RemainAfterExit=yes
User=nginx
Group=nginx
[Install]
WantedBy=multi-user.target
Guardar y salir.
Vuelva a cargar el servicio systemd e inicie seafile y seahub con systemctl.
systemctl daemon-reload
systemctl start seafile
systemctl start seahub
Asegúrate de que no haya ningún error y verifica que el servicio seafile y seahub se esté ejecutando en los puertos 8082 y 8000.
netstat -plntu
Paso 6:generar archivos de certificado SSL
Para este tutorial, ejecutaremos seafile sobre un proxy Nginx, y Nginx proporcionará conexiones seguras (HTTPS) para la seguridad de los datos. Podemos utilizar un archivo de certificado SSL gratuito o el certificado SSL de pago, esto no importa para la configuración. En este paso, generaré un archivo de certificado SSL autofirmado con OpenSSL en el directorio '/etc/nginx/ssl'.
Cree el directorio ssl.
mkdir -p /etc/nginx/ssl
cd /etc/nginx/ssl
Genere archivos de certificado autofirmados y un archivo dhparam con el siguiente comando:
openssl dhparam -out /etc/nginx/ssl/dhparam.pem 2048
openssl req -new -x509 -sha256 -days 365 -newkey rsa:2048 -nodes -keyout server.key -out server.crt
Responda los detalles del certificado según lo solicite OpenSSL, como su nombre, estado, correo electrónico, nombre de dominio, etc. Luego, cambie los permisos del directorio y los archivos del certificado.
chmod -R 700 /etc/nginx/ssl
chmod 400 server.*
chmod 400 dhparam.pem
Se han generado los archivos del certificado SSL.
Paso 7:configurar Nginx como proxy inverso
En este paso, configuraremos Nginx como proxy inverso para el servidor de archivos marinos en los puertos 8000 y 8002.
Vaya al directorio de configuración de nginx y cree un nuevo archivo de host virtual para seafile.
cd /etc/nginx/
vim conf.d/seafile.conf
Pegue la configuración del host virtual a continuación:
server {
listen 80;
server_name cloud.natsume.co;
return 301 https://$host$request_uri;
}
server {
listen 443 ssl;
server_name cloud.natsume.co;
ssl on;
ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
ssl_certificate /etc/nginx/ssl/server.crt;
ssl_certificate_key /etc/nginx/ssl/server.key;
ssl_ciphers 'ECDHE-RSA-AES256-GCM-SHA384:ECDHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-SHA384:ECDHE-RSA-AES128-SHA256:ECDHE-RSA-AES256-SHA:ECDHE-RSA-AES128-SHA:DHE-RSA-AES256-SHA256:DHE-RSA-AES128-SHA256:DHE-RSA-AES256-SHA:DHE-RSA-AES128-SHA:ECDHE-RSA-DES-CBC3-SHA:EDH-RSA-DES-CBC3-SHA:AES256-GCM-SHA384:AES128-GCM-SHA256:AES256-SHA256:AES128-SHA256:AES256-SHA:AES128-SHA:DES-CBC3-SHA:HIGH:!aNULL:!eNULL:!EXPORT:!CAMELLIA:!DES:!MD5:!PSK:!RC4';
ssl_dhparam /etc/nginx/ssl/dhparam.pem;
ssl_prefer_server_ciphers on;
location / {
fastcgi_pass 127.0.0.1:8000;
fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
fastcgi_param PATH_INFO $fastcgi_script_name;
fastcgi_param SERVER_PROTOCOL $server_protocol;
fastcgi_param QUERY_STRING $query_string;
fastcgi_param REQUEST_METHOD $request_method;
fastcgi_param CONTENT_TYPE $content_type;
fastcgi_param CONTENT_LENGTH $content_length;
fastcgi_param SERVER_ADDR $server_addr;
fastcgi_param SERVER_PORT $server_port;
fastcgi_param SERVER_NAME $server_name;
fastcgi_param REMOTE_ADDR $remote_addr;
access_log /var/log/nginx/seahub.access.log;
error_log /var/log/nginx/seahub.error.log;
fastcgi_read_timeout 36000;
}
# Reverse Proxy for seahub
location /seafhttp {
rewrite ^/seafhttp(.*)$ $1 break;
proxy_pass http://127.0.0.1:8082;
client_max_body_size 0;
proxy_connect_timeout 36000s;
proxy_read_timeout 36000s;
proxy_send_timeout 36000s;
send_timeout 36000s;
}
#CHANGE THIS PATH WITH YOUR OWN DIRECTORY
location /media {
root /var/www/seafile/seafile-server/seahub;
}
} Guardar y salir.
Usaré 'cloud.natsume.co' como nombre de dominio. Reemplácelo con su propio nombre de dominio en la configuración anterior.
Ahora pruebe la configuración de Nginx y asegúrese de que no haya errores.
nginx -t
Inicie Nginx con el comando systemctl:
systemctl start nginx
Asegúrese de que los puertos 80 y 443 estén disponibles en la lista que proporciona netstat:
netstat -plntu
A continuación, debemos agregar el nombre de dominio a la configuración del archivo marino. Vaya al directorio seafile y edite el archivo de configuración.
cd /var/www/seafile/
vim conf/ccnet.conf
Cambie la URL del servicio a su nombre de dominio.
SERVICE_URL = https://cloud.natsume.co
Guardar y salir.
Edite el archivo de configuración de seahub.
vim conf/seahub_settings.py
En la segunda línea, agregue la configuración a continuación:
HTTP_SERVER_ROOT = 'https://cloud.natsume.co/seafhttp'
Reemplace el nombre de dominio con su dominio aquí nuevamente. Guardar y salir.
Reinicie Seafile y agregue todos los servicios para que comiencen en el momento del arranque:
systemctl restart seafile
systemctl restart seahub
systemctl enable nginx
systemctl enable mariadb
systemctl enable seafile
systemctl enable seahub
Paso 8:configurar el cortafuegos
En el paso 7, configuramos Nginx para usar el puerto HTTP y HTTPS. Ahora tenemos que abrir esos puertos en el Firewall agregándolos a firewalld.
Iniciar cortafuegos.
systemctl start firewalld
systemctl enable firewalld
Agregue el puerto HTTP y HTTPS a la configuración del firewall con el siguiente comando firewall-cmd:
firewall-cmd --zone=public --add-port=80/tcp --permanent
firewall-cmd --zone=public --add-port=443/tcp --permanent
Vuelva a cargar la configuración del cortafuegos y compruebe la lista de puertos.
firewall-cmd --reload
firewall-cmd --list-all
Paso 9:prueba de Seafile
Abra su navegador, escriba el nombre de dominio del archivo marino, en mi caso cloud.natsume.co y será redirigido a la conexión https.
Escriba su correo electrónico y contraseña de administrador y haga clic en 'Iniciar sesión'.
Panel de administración de Seafile:
Vista de archivo Seafile.
Seafile con Nginx como proxy inverso y SSL se instaló correctamente en el servidor CentOS 7.
Conclusión
Con la amplia variedad de aplicaciones en la nube de hoy, Seafile es una solución de nube privada que es buena para usar en este día. Con la función de cifrado a nivel de biblioteca/carpeta, puede almacenar sus datos de forma segura en un servidor Seacloud. Además, Seafile es fácil de configurar e implementar en su propio servidor.