One place for hosting & domains

      Sincronizar

      Cómo usar Rsync para sincronizar directorios locales y remotos


      Introducción

      Rsync, que significa “sincronización remota”, es una herramienta de sincronización de archivos remotos y locales. Utiliza un algoritmo que minimiza la cantidad de datos copiados, moviendo solo las partes de los archivos que cambiaron.

      En esta guía, explicaremos el manejo básico de esta potente utilidad.

      ¿Qué es Rsync?

      Rsync es una herramienta de sincronización muy flexible y habilitada para la red. Debido a su presencia universal en sistemas Linux y sistemas similares a Unix, y su popularidad como herramienta para las secuencias de comandos del sistema, se incluye en la mayoría de las distribuciones de Linux de manera predeterminada.

      Sintaxis básica

      La sintaxis básica de rsync es muy sencilla, y opera de forma similar a ssh, scp y cp.

      Crearemos dos directorios de prueba y algunos archivos de prueba con los siguientes comandos:

      • cd ~

      • mkdir dir1

      • mkdir dir2

      • touch dir1/file{1..100}

      Ahora, tenemos un directorio llamado dir1 con 100 archivos vacíos.

      Output
      file1    file18  file27  file36  file45  file54  file63  file72  file81  file90
file10   file19  file28  file37  file46  file55  file64  file73  file82  file91
file100  file2   file29  file38  file47  file56  file65  file74  file83  file92
file11   file20  file3   file39  file48  file57  file66  file75  file84  file93
file12   file21  file30  file4   file49  file58  file67  file76  file85  file94
file13   file22  file31  file40  file5   file59  file68  file77  file86  file95
file14   file23  file32  file41  file50  file6   file69  file78  file87  file96
file15   file24  file33  file42  file51  file60  file7   file79  file88  file97
file16   file25  file34  file43  file52  file61  file70  file8   file89  file98
file17   file26  file35  file44  file53  file62  file71  file80  file9   file99

      También tenemos un directorio vacío llamado dir2.

      Para sincronizar el contenido de dir1 a dir2 en el mismo sistema, escriba lo siguiente:

      La opción -r significa recursiva, que es necesaria para la sincronización de directorios.

      También podríamos utilizar el indicador -a en su lugar:

      La opción -a es un indicador combinado. Significa “archivo” y sincroniza de manera recursiva, además conserva los enlaces simbólicos, los archivos especiales y de dispositivo, fechas de modificación, grupo, propietario y permisos. Se utiliza más con más frecuencia que -r y, generalmente, es lo que querrá utilizar.

      Nota importante

      Es posible que haya notado que hay una barra diagonal (/) al final del primer argumento en los comandos anteriores:

      Eso es necesario para referirse a “el contenido de dir1”. La alternativa, sin la barra diagonal, colocaría dir1, incluyendo el directorio, dentro de dir2. Eso crearía una jerarquía similar a esta:

      Siempre compruebe los argumentos antes de ejecutar un comando rsync. Rsync ofrece un método para hacer esto pasando las opciones -n o --dry-run. El indicador -v (para modo detallado) también es necesario para obtener el resultado adecuado:

      Output
      sending incremental file list
./
file1
file10
file100
file11
file12
file13
file14
file15
file16
file17
file18
. . .

      Compare este resultado con el resultado que obtenemos cuando eliminamos la barra diagonal:

      Output
      sending incremental file list
dir1/
dir1/file1
dir1/file10
dir1/file100
dir1/file11
dir1/file12
dir1/file13
dir1/file14
dir1/file15
dir1/file16
dir1/file17
dir1/file18
. . .

      Puede ver que el directorio en sí se transfiere.

      Cómo usar Rsync para sincronizar con un sistema remoto

      La sincronización con un sistema remoto es trivial si tiene acceso SSH al equipo remoto y rsync instalado en ambos sitios. Una vez que tenga el acceso SSH verificado entre los dos equipos, puede sincronizar la carpeta dir1 anterior con una computadora remota utilizando esta sintaxis (tenga en cuenta que, en este caso, queremos transferir el propio directorio, por lo que omitimos la barra diagonal):

      • rsync -a ~/dir1 username@remote_host:destination_directory

      Eso se conoce como una operación “push” porque empuja un directorio del sistema local a un sistema remoto. La operación opuesta se conoce como “pull”. Se utiliza para sincronizar un directorio remoto con el sistema local. Si el dir1 estuviera en el sistema remoto, y no en nuestro sistema local, la sintaxis sería la siguiente:

      • rsync -a username@remote_host:/home/username/dir1 place_to_sync_on_local_machine

      Al igual que el cp y otras herramientas similares, la fuente siempre es el primer argumento, y el destino siempre es el segundo.

      Opciones útiles para Rsync

      Rsync proporciona muchas opciones para alterar el comportamiento predeterminado de la utilidad. Ya hablamos de algunos de los indicadores más importantes.

      Si está transfiriendo archivos que aún no se comprimieron, como los archivos de texto, puede reducir la transferencia de la red comprimiendo con la opción -z:

      • rsync -az source destination

      El indicador -P es muy útil. Combina los indicadores --progress y --partial. El primero de ellos le proporciona una barra de progreso para las transferencias, y el segundo le permite reanudar las transferencias interrumpidas:

      • rsync -azP source destination

      Output
      sending incremental file list
./
file1
           0 100%    0.00kB/s    0:00:00 (xfer#1, to-check=99/101)
file10
           0 100%    0.00kB/s    0:00:00 (xfer#2, to-check=98/101)
file100
           0 100%    0.00kB/s    0:00:00 (xfer#3, to-check=97/101)
file11
           0 100%    0.00kB/s    0:00:00 (xfer#4, to-check=96/101)
. . .

      Si volvemos a ejecutar el comando, obtendremos un resultado más corto porque no se produjeron cambios. Eso ilustra la capacidad de rsync de utilizar las fechas de modificación para determinar si se realizaron cambios.

      • rsync -azP source destination

      Output
      sending incremental file list
sent 818 bytes received 12 bytes 1660.00 bytes/sec
total size is 0 speedup is 0.00

      Podemos actualizar la fecha de modificación en algunos de los archivos y ver que rsync vuelve a copiar de manera inteligente solo los archivos modificados:

      • touch dir1/file{1..10}

      • rsync -azP source destination

      Output
      sending incremental file list
file1
            0 100%    0.00kB/s    0:00:00 (xfer#1, to-check=99/101)
file10
            0 100%    0.00kB/s    0:00:00 (xfer#2, to-check=98/101)
file2
            0 100%    0.00kB/s    0:00:00 (xfer#3, to-check=87/101)
file3
            0 100%    0.00kB/s    0:00:00 (xfer#4, to-check=76/101)
. . .

      Para mantener dos directorios realmente sincronizados, es necesario eliminar los archivos del directorio destino si se eliminan de la fuente. De forma predeterminada, rsync no elimina nada del directorio de destino.

      Podemos cambiar este comportamiento con la opción --delete. Antes de utilizar esta opción, utilice la opción --dry-run y realice pruebas para evitar la pérdida de datos:

      • rsync -a --delete source destination

      Si desea excluir ciertos archivos o directorios ubicados en un directorio que está sincronizando, puede hacerlo especificándolos en una lista separada por comas, siguiendo la opción --exclude=:

      • rsync -a --exclude=pattern_to_exclude source destination

      Si especificamos un patrón para excluir, podemos anular esa exclusión para archivos que coincidan con un patrón diferente utilizando la opción --include=.

      • rsync -a --exclude=pattern_to_exclude --include=pattern_to_include source destination

      Por último, la opción --backup de rsync se puede utilizar para almacenar copias de seguridad de archivos importantes. Se utiliza en conjunto con la opción --backup-dir, que especifica el directorio en donde las copias de seguridad de los archivos se deben almacenar.

      • rsync -a --delete --backup --backup-dir=/path/to/backups /path/to/source destination

      Conclusión

      Rsync puede simplificar la transferencia de archivos a través de conexiones de red y robustecer la sincronización de directorios locales. La flexibilidad de rsync lo convierte en una buena opción para muchas operaciones con diferentes niveles de archivo.

      Dominar rsync le permite diseñar operaciones de respaldo complejas y obtener un control detallado sobre qué se transfiere y cómo.



      Source link

      Como usar o Rsync para sincronizar diretórios locais e remotos


      Introdução

      O Rsync, que significa “sincronização remota”, é uma ferramenta de sincronização remota e local. Ele usa um algoritmo que minimiza a quantidade de dados copiados ao mover apenas as porções de arquivos que foram alteradas.

      Neste guia, iremos abordar o uso básico deste utilitário poderoso.

      O que é o Rsync?

      O Rsync é uma ferramenta de sincronização habilitada em rede muito. Devido à sua onipresença em sistemas Linux e do tipo Unix, além da sua popularidade como uma ferramenta para scripts de sistema, ela é incluída na maioria das distribuições Linux por padrão.

      Sintaxe básica

      A sintaxe básica do rsync é bastante simples e opera de uma maneira semelhante ao ssh, scp e cp.

      Vamos criar dois diretórios de teste e alguns arquivos de teste com os seguintes comandos:

      • cd ~

      • mkdir dir1

      • mkdir dir2

      • touch dir1/file{1..100}

      Agora, temos um diretório chamado dir1 contendo 100 arquivos vazios.

      Output
      file1    file18  file27  file36  file45  file54  file63  file72  file81  file90
file10   file19  file28  file37  file46  file55  file64  file73  file82  file91
file100  file2   file29  file38  file47  file56  file65  file74  file83  file92
file11   file20  file3   file39  file48  file57  file66  file75  file84  file93
file12   file21  file30  file4   file49  file58  file67  file76  file85  file94
file13   file22  file31  file40  file5   file59  file68  file77  file86  file95
file14   file23  file32  file41  file50  file6   file69  file78  file87  file96
file15   file24  file33  file42  file51  file60  file7   file79  file88  file97
file16   file25  file34  file43  file52  file61  file70  file8   file89  file98
file17   file26  file35  file44  file53  file62  file71  file80  file9   file99

      Também temos um diretório vazio chamado dir2.

      Para sincronizar o conteúdo de dir1 em dir2 no mesmo sistema, digite:

      A opção -r significa recursivo, que é necessário para a sincronização de diretórios.

      Também poderíamos usar o sinalizador -a como alternativa:

      A opção -a é um sinalizador de combinação. Ela representa “arquivo” e sincroniza recursivamente e preserva links simbólicos, arquivos especiais e de dispositivo, horários de modificação, grupo, proprietário e permissões. Ela é mais comumente usada do que -r e geralmente é o que você vai desejar usar.

      Uma nota importante

      Você pode ter notado que existe uma barra à direita (/) no final do primeiro argumento nos comandos acima:

      Isso é necessário e significa “o conteúdo de dir1”. A alternativa, sem a barra à direita, colocaria o dir1, incluindo o diretório, dentro do dir2. Isso criaria uma hierarquia como esta:

      Sempre verifique duas vezes seus argumentos antes de executar um comando rsync. O Rsync fornece um método para fazer isso passando as opções -n ou --dry-run. O sinalizador -v (para verboso, prolixo) também é necessário para obter o resultado apropriado:

      Output
      sending incremental file list
./
file1
file10
file100
file11
file12
file13
file14
file15
file16
file17
file18
. . .

      Compare esse resultado com o resultado que obtemos ao remover a barra à direita:

      Output
      sending incremental file list
dir1/
dir1/file1
dir1/file10
dir1/file100
dir1/file11
dir1/file12
dir1/file13
dir1/file14
dir1/file15
dir1/file16
dir1/file17
dir1/file18
. . .

      Você pode ver aqui que o diretório em si foi transferido.

      Sincronizar com um sistema remoto é trivial se você possuir acesso SSH à máquina remota e o rsync instalado em ambos os lados. Depois de ter o acesso SSH verificado entre as duas máquinas, sincronize a pasta dir1 de antes com um computador remoto usando esta sintaxe (observe que queremos transferir o diretório real neste caso, então omitimos a barra à direita):

      • rsync -a ~/dir1 username@remote_host:destination_directory

      Isso é chamado de uma operação “push”, pois empurra um diretório do sistema local para um sistema remoto. A operação oposta é “pull”. Ela é usada para sincronizar um diretório remoto com o sistema local. Se o dir1 estivesse no sistema remoto em vez de no nosso sistema local, a sintaxe seria:

      • rsync -a username@remote_host:/home/username/dir1 place_to_sync_on_local_machine

      Assim como cp e ferramentas similares, a fonte é sempre o primeiro argumento, e o destino é sempre o segundo.

      Opções úteis para o Rsync

      O Rsync oferece muitas opções para alterar o comportamento padrão do utilitário. Já discutimos alguns dos sinalizadores mais necessários.

      Se estiver transferindo arquivos que ainda não foram comprimidos, como arquivos de texto, você pode reduzir a transferência de rede adicionando compressão com a opção -z:

      • rsync -az source destination

      O sinalizador -P é muito útil. Ele combina os sinalizadores --progress e --partial. O primeiro deles lhe dá uma barra de progresso para as transferências e o segundo lhe permite retomar as transferências interrompidas:

      • rsync -azP source destination

      Output
      sending incremental file list
./
file1
           0 100%    0.00kB/s    0:00:00 (xfer#1, to-check=99/101)
file10
           0 100%    0.00kB/s    0:00:00 (xfer#2, to-check=98/101)
file100
           0 100%    0.00kB/s    0:00:00 (xfer#3, to-check=97/101)
file11
           0 100%    0.00kB/s    0:00:00 (xfer#4, to-check=96/101)
. . .

      Se executarmos o comando novamente, teremos um resultado mais curto, pois nenhuma alteração foi feita. Isso ilustra a capacidade do rsync de usar horários de modificação para determinar se alterações foram feitas.

      • rsync -azP source destination

      Output
      sending incremental file list
sent 818 bytes received 12 bytes 1660.00 bytes/sec
total size is 0 speedup is 0.00

      Podemos atualizar o horário de modificação em alguns arquivos e ver que o rsync copia novamente de maneira inteligente apenas os arquivos alterados:

      • touch dir1/file{1..10}

      • rsync -azP source destination

      Output
      sending incremental file list
file1
            0 100%    0.00kB/s    0:00:00 (xfer#1, to-check=99/101)
file10
            0 100%    0.00kB/s    0:00:00 (xfer#2, to-check=98/101)
file2
            0 100%    0.00kB/s    0:00:00 (xfer#3, to-check=87/101)
file3
            0 100%    0.00kB/s    0:00:00 (xfer#4, to-check=76/101)
. . .

      Para manter dois diretórios realmente sincronizados, é necessário excluir arquivos do diretório de destino caso eles sejam removidos da fonte. Por padrão, o rsync não exclui nada do diretório de destino.

      Podemos alterar esse comportamento com a opção --delete. Antes de usar essa opção, use a opção --dry-run e faça testes para impedir a perda de dados:

      • rsync -a --delete source destination

      Se quiser excluir certos arquivos ou diretórios localizados dentro de um diretório que você está sincronizando, faça isso os especificando em uma lista separada por vírgulas após a opção --exclude=:

      • rsync -a --exclude=pattern_to_exclude source destination

      Se especificarmos um padrão para excluir, podemos sobrescrever essa exclusão para arquivos que correspondam a um padrão diferente usando a opção --include=.

      • rsync -a --exclude=pattern_to_exclude --include=pattern_to_include source destination

      Por fim, a opção ---backup do rsync pode ser usada para armazenar backups de arquivos importantes. Ela é usada em conjunto com a opção --backup-dir, que especifica o diretório onde os arquivos de backup devem ser armazenados.

      • rsync -a --delete --backup --backup-dir=/path/to/backups /path/to/source destination

      Conclusão

      O Rsync pode simplificar as transferências de arquivos em conexões de rede e adicionar robustez à sincronização de diretórios locais. A flexibilidade do rsync faz com que ele seja uma boa opção para muitas operações de nível de arquivos diferentes.

      O domínio do rsync permite projetar operações de backup complexas e ganhar controle refinado sobre o que é transferido e a forma como isso é feito.



      Source link

      Como Sincronizar e Compartilhar Seus Arquivos com o Seafile no Debian 10


      Introdução

      O Seafile é uma plataforma de compartilhamento e sincronização de arquivos open-source e auto-hospedada. Os usuários podem armazenar e, opcionalmente, criptografar dados em seus próprios servidores, tendo o espaço de armazenamento como única limitação. Com o Seafile, você pode compartilhar arquivos e pastas usando links de sincronização multi-plataformas e protegidos por senha para arquivos com datas de validade. O recurso de versionamento de arquivo significa que os usuários podem restaurar arquivos ou pastas excluídos e modificados.

      Neste tutorial, você instalará e configurará o Seafile em um servidor Debian 10. Você usará o MariaDB (a variante padrão do MySQL no Debian 10) para armazenar dados para os diferentes componentes do Seafile e o Apache como servidor proxy para lidar com o tráfego web. Após concluir este tutorial, você poderá usar a interface web para acessar o Seafile a partir de clientes móveis ou desktops, permitindo sincronizar e compartilhar seus arquivos com outros usuários ou grupos no servidor ou com o público.

      Pré-requisitos

      Antes de começar este guia, você precisará do seguinte:

      Passo 1 — Criando Bancos de Dados para os Componentes do Seafile

      O Seafile requer três componentes para funcionar corretamente:

      • Seahub: O front-end web do Seafile, escrito em Python usando o framework web Django. A partir do Seahub, você pode acessar, gerenciar e compartilhar seus arquivos usando um navegador web.
      • Seafile server: O daemon do serviço de dados que gerencia o upload, o download e a sincronização de arquivos raw. Você não interage diretamente com o servidor, mas usa um programa cliente ou a interface web Seahub.
      • Ccnet server: O daemon de serviço RPC para permitir a comunicação interna entre os diferentes componentes do Seafile. Por exemplo, quando você usa o Seahub, ele pode acessar dados do servidor Seafile usando o serviço RPC Ccnet.

      Cada um desses componentes armazena seus dados separadamente em seu próprio banco de dados. Neste passo, você criará os três bancos de dados MariaDB e um usuário antes de prosseguir com a configuração do servidor.

      Primeiro, efetue login no servidor usando SSH com seu nome de usuário e endereço IP:

      ssh sammy@ip_do_seu_servidor

      Conecte-se ao servidor de banco de dados MariaDB como administrador (root):

      No prompt do MariaDB, use o seguinte comando SQL para criar o usuário do banco de dados:

      • CREATE USER 'sammy'@'localhost' IDENTIFIED BY 'senha';

      Em seguida, você criará os seguintes bancos de dados para armazenar os dados dos três componentes do Seafile:

      • ccnet-db para o servidor Ccnet.
      • seahub-db para o frontend web Seahub.
      • seafile-db para o servidor Seafile.

      No prompt do MariaDB, crie seus bancos de dados:

      • CREATE DATABASE 'ccnet-db' CHARACTER SET = 'utf8';

      • CREATE DATABASE 'seafile-db' CHARACTER SET = 'utf8';

      • CREATE DATABASE 'seahub-db' CHARACTER SET = 'utf8';

      Em seguida, conceda todos os privilégios ao seu usuário de banco de dados para acessar e fazer alterações nesses bancos de dados:

      • GRANT ALL PRIVILEGES ON 'ccnet-db'.* to 'sammy'@localhost;

      • GRANT ALL PRIVILEGES ON 'seafile-db'.* to 'sammy'@localhost;

      • GRANT ALL PRIVILEGES ON 'seahub-db'.* to 'sammy'@localhost;

      Saia do prompt do MariaDB digitando exit:

      Agora que você criou um usuário e os bancos de dados necessários para armazenar os dados de cada um dos componentes do Seafile, você instalará as dependências para baixar o pacote do servidor Seafile.

      Passo 2 — Instalando Dependências e Baixando o Seafile

      Algumas partes do Seafile são escritas em Python e, portanto, requerem módulos e programas adicionais em Python para funcionar. Neste passo, você instalará essas dependências necessárias antes de baixar e extrair o pacote do servidor Seafile.

      Para instalar as dependências usando o apt, execute o seguinte comando:

      • sudo apt install python-setuptools python-pip python-urllib3 python-requests python-mysqldb ffmpeg

      As dependências python-setuptools e python-pip supervisionam a instalação e o gerenciamento de pacotes Python. Os pacotes python-urllib3 e python-orders fazem solicitações aos websites. Finalmente, o python-mysqldb é uma biblioteca para usar o MariaDB no Python e o ffmpeg lida com arquivos multimídia.

      O Seafile requer o Pillow, uma biblioteca python para processamento de imagens, e o moviepy para lidar com as miniaturas dos arquivos de filmes. Estes módulos não estão disponíveis no repositório de pacotes Debian, então instale-os com o pip:

      • sudo pip install Pillow moviepy

      Agora que você instalou as dependências necessárias, pode fazer o download do pacote do servidor Seafile.

      O Seafile cria diretórios adicionais durante a instalação. Para mantê-los todos organizados, crie um novo diretório e mude para ele:

      Você pode baixar a versão mais recente (7.0.4 no momento em que este artigo foi escrito) do servidor Seafile a partir do website do projeto executando este comando:

      • wget https://download.seadrive.org/seafile-server_7.0.4_x86-64.tar.gz

      O Seafile distribui o download como um arquivo tar compactado, o que significa que você precisará extraí-lo antes de continuar. Extraia o arquivo usando tar:

      • tar -zxvf seafile-server_7.0.4_x86-64.tar.gz

      Agora mude para o diretório extraído:

      Nesta fase, você baixou e extraiu o pacote do servidor Seafile e também instalou as dependências necessárias. Agora você está pronto para configurar o servidor Seafile.

      Passo 3 — Configurando o Servidor Seafile

      O Seafile precisa de algumas informações sobre sua configuração antes de iniciar os serviços pela primeira vez. Isso inclui detalhes como o nome do domínio, a configuração do banco de dados e o caminho em que os dados serão armazenados. Para iniciar a série de solicitações de perguntas para fornecer essas informações, você pode executar o script setup_seafile_mysql.sh, incluído no arquivo que você extraiu na etapa anterior.

      Execute o script usando o bash:

      • bash setup-seafile-mysql.sh

      Pressione ENTER para continuar quando solicitado.

      O script agora fará uma série de perguntas. Onde quer que os padrões sejam mencionados, pressionar a tecla ENTER utilizará esse valor.

      Este tutorial usa Seafile como o nome do servidor, mas você pode alterá-lo se desejar:

      Question 1

What is the name of the server?
It will be displayed on the client. 3 - 15 letters or digits
[ server name ] Seafile

      Para Question 2, digite o nome de domínio para esta instância do Seafile.

      Question 2

What is the ip or domain of the server?.
For example: www.mycompany.com, 192.168.1.101
[ This server's ip or domain ] seu_domínio

      Pressione ENTER para aceitar o valor padrão para a Question 3. Se você configurou o armazenamento externo, por exemplo, usando NFS ou armazenamento em bloco, precisará especificar o caminho para esse local aqui.

      Question 3

Where do you want to put your seafile data?
Please use a volume with enough free space
[ default "/home/sammy/seafile/seafile-data" ]

      Para Question 4 pressione ENTER para aceitar o número da porta padrão.

      Question 4

Which port do you want to use for the seafile fileserver?
[ default "8082" ]

      O próximo prompt permite confirmar a configuração do banco de dados. Você pode criar novos bancos de dados ou usar bancos de dados existentes para configuração. Para este tutorial, você criou os bancos de dados necessários no Passo 1, então selecione a opção 2 aqui.

      -------------------------------------------------------
Please choose a way to initialize seafile databases:
-------------------------------------------------------

[1] Create new ccnet/seafile/seahub databases
[2] Use existing ccnet/seafile/seahub databases

[ 1 or 2 ] 2

      As perguntas 6 a 9 estão relacionadas ao servidor de banco de dados MariaDB. Você precisa fornecer o nome de usuário e a senha do usuário MySQL que você criou no Passo 1, mas você pode pressionar ENTER para aceitar os valores padrão para host e port.

      
What is the host of mysql server?

[ default "localhost" ]

What is the port of mysql server?

[ default "3306" ]

Which mysql user to use for seafile?

[ mysql user for seafile ] sammy

What is the password for mysql user "seafile"?

[ password for seafile ] senha

      Após fornecer a senha, o script solicitará os nomes dos bancos de dados do Seafile. Use ccnet-db, seafile-db, e seahub-db para este tutorial. O script verificará se há uma conexão bem-sucedida aos bancos de dados antes de continuar exibindo um resumo da configuração inicial.

      Enter the existing database name for ccnet:
[ ccnet database ] ccnet-db

verifying user "sammy" access to database ccnet-db ...  done

Enter the existing database name for seafile:
[ seafile database ] seafile-db

verifying user "sammy" access to database seafile-db ...  done

Enter the existing database name for seahub:
[ seahub database ] seahub-db

verifying user "sammy For this tutorial you have" access to database seahub-db ...  done

---------------------------------
This is your configuration
---------------------------------

    server name:            Seafile
    server ip/domain:       seu_domínio

    seafile data dir:       /home/sammy/seafile/seafile-data
    fileserver port:        8082

    database:               use existing
    ccnet database:         ccnet-db
    seafile database:       seafile-db
    seahub database:        seahub-db
    database user:          sammy

--------------------------------
Press ENTER to continue, or Ctrl-C to abort
---------------------------------

      Pressione ENTER para confirmar.

      Output
      Generating ccnet configuration ...
done
Successly create configuration dir /home/sammy/seafile/ccnet.

Generating seafile configuration ...                
done

Generating seahub configuration ...
----------------------------------------
Now creating seahub database tables ...
----------------------------------------
creating seafile-server-latest symbolic link ...  done

-----------------------------------------------------------------
Your seafile server configuration has been finished successfully.
-----------------------------------------------------------------
run seafile server:     ./seafile.sh { start | stop | restart }
run seahub  server:     ./seahub.sh  { start <port> | stop | restart <port> }
-----------------------------------------------------------------
If you are behind a firewall, remember to allow input/output of these tcp ports:
-----------------------------------------------------------------
port of seafile fileserver:   8082
port of seahub:               8000

When problems occur, Refer to
        https://github.com/haiwen/seafile/wiki
for information.

      Você estará executando o Seafile atrás do Apache, o que você já permitiu através do firewall do servidor. Portanto, você não precisa se preocupar em abrir as portas 8082 e 8000 e pode ignorar essa parte da saída.

      Você concluiu a configuração inicial do servidor. No próximo passo, você configurará o servidor web Apache antes de iniciar os serviços do Seafile.

      Passo 4 — Configurando o Servidor Web Apache

      Nesta etapa, você configurará o servidor web Apache para encaminhar todas as solicitações ao Seafile. O uso do Apache dessa maneira permite que você use uma URL sem um número de porta, habilite conexões HTTPS com o Seafile e utilize a funcionalidade de armazenamento em cache fornecida pelo Apache para obter melhor desempenho.

      Para começar a encaminhar solicitações, você precisará habilitar o módulo proxy_http na configuração do Apache. Este módulo fornece recursos para fazer proxy de solicitações HTTP e HTTPS. O seguinte comando ativará o módulo:

      Nota: Os módulos Apache rewrite e ssl também são necessários para esta configuração. Você já ativou esses módulos como parte da configuração do Let’s Encrypt no segundo tutorial do Apache listado na seção de pré-requisitos.

      Em seguida, atualize a configuração do virtual host do seu_domínio para encaminhar solicitações ao servidor de arquivos Seafile e à interface web Seahub.

      Abra o arquivo de configuração em um editor de texto:

      • sudo nano /etc/apache2/sites-enabled/seu_domínio-le-ssl.conf

      As linhas de ServerAdmin até SSLCertificateKeyFile fazem parte da configuração inicial do Apache e do Let’s Encrypt que você definiu nos tutoriais de pré-requisito. Adicione o conteúdo destacado, iniciando em Alias e terminando com a diretiva ProxyPassReverse:

      /etc/apache2/sites-enabled/your_domain-le-ssl.conf

      
<IfModule mod_ssl.c>
<VirtualHost *:443>
    ServerAdmin admin@seu_domínio_de_email
    ServerName seu_domínio
    ServerAlias www.seu_domínio
    DocumentRoot /var/www/seu_domínio/html
    ErrorLog ${APACHE_LOG_DIR}/seu_domínio-error.log
    CustomLog ${APACHE_LOG_DIR}/seu_domínio-access.log combined

    Include /etc/letsencrypt/options-ssl-apache.conf
    SSLCertificateFile /etc/letsencrypt/live/seu_domínio/fullchain.pem
    SSLCertificateKeyFile /etc/letsencrypt/live/seu_domínio/privkey.pem

    Alias /media  /home/sammy/seafile/seafile-server-latest/seahub/media
    <Location /media>
        Require all granted
    </Location>

    # seafile fileserver
    ProxyPass /seafhttp http://127.0.0.1:8082
    ProxyPassReverse /seafhttp http://127.0.0.1:8082
    RewriteEngine On
    RewriteRule ^/seafhttp - [QSA,L]

    # seahub web interface
    SetEnvIf Authorization "(.*)" HTTP_AUTHORIZATION=$1
    ProxyPass / http://127.0.0.1:8000/
    ProxyPassReverse / http://127.0.0.1:8000/
</VirtualHost>
</IfModule>

      A diretiva Alias mapeia o caminho da URL seu_domínio/media para um caminho local no sistema de arquivos que o Seafile utiliza. A diretiva seguinte, Location, habilita o acesso ao conteúdo deste diretório. As diretivas ProxyPass e ProxyPassReverse fazem o Apache agir como um proxy reverso para este host, encaminhando solicitações para / e /seafhttp para a interface web e para o servidor de arquivos Seafile em execução nas portas do host local 8000 e 8082 respectivamente. A diretiva RewriteRule passa todas as solicitações para /seafhttp inalteradas e interrompe o processamento de novas regras ([QSA,L]).

      Salve e saia do arquivo.

      Teste se há algum erro de sintaxe na configuração do virtual host:

      • sudo apache2ctl configtest

      Se ele informar Syntax OK, então não há problemas com sua configuração. Reinicie o Apache para que as alterações entrem em vigor:

      • sudo systemctl restart apache2

      Agora você configurou o Apache para atuar como um proxy reverso para o servidor de arquivos Seafile e o Seahub. Em seguida, você atualizará as URLs na configuração do Seafile antes de iniciar os serviços.

      Passo 5 — Atualizando a Configuração do Seafile e Iniciando os Serviços

      Agora que você está usando o Apache para fazer proxy de todas as solicitações para o Seafile, será necessário atualizar as URLs nos arquivos de configuração do Seafile no diretório conf usando um editor de texto antes de iniciar o serviço Seafile.

      Abra ccnet.conf em um editor de texto:

      • nano /home/sammy/seafile/conf/ccnet.conf

      Perto do topo do arquivo, dentro do bloco [General], está a diretiva SERVICE_URL. Ela parecerá assim:

      Update /home/sammy/seafile/conf/ccnet.conf

      . . .
SERVICE_URL=http://www.example.com:8000
. . .

      Modifique essa configuração para apontar para o seu domínio. Verifique se a URL fornecida usa o protocolo HTTPS e se não inclui nenhum número de porta:

      Update /home/sammy/seafile/conf/ccnet.conf

      . . .
SERVICE_URL = https://seu_domínio
. . .

      Salve e saia do arquivo depois de adicionar o conteúdo.

      Agora abra seahub_settings.py em um editor de texto:

      • nano /home/sammy/seafile/conf/seahub_settings.py

      Adicione uma configuração FILE_SERVER_ROOT no arquivo para especificar o caminho onde o servidor de arquivos está atendendo a uploads e downloads de arquivos:

      Update /home/sammy/seafile/conf/seahub_settings.py

      # -*- coding: utf-8 -*-
SECRET_KEY = "..."
FILE_SERVER_ROOT = 'https://seu_domínio/seafhttp'
# ...

      Salve e saia do arquivo seahub_settings.py.

      Agora você pode iniciar o serviço Seafile e a interface Seahub:

      • cd /home/sammy/seafile/seafile-server-7.0.4

      • ./seafile.sh start

      • ./seahub.sh start

      Como esta é a primeira vez que você inicia o serviço Seahub, ele solicita que você crie uma conta de administrador. Digite um endereço de email válido e uma senha para este usuário administrador:

      Output
      What is the email for the admin account?
[ admin email ] admin@seu_domínio_de_email

What is the password for the admin account?
[ admin password ] senha

Enter the password again:
[ admin password again ] senha

----------------------------------------
Successfully created seafile admin
----------------------------------------
Seahub is started

Done.

      Abra https://seu_domínio em um navegador web e faça login usando seu endereço de e-mail e a senha de administrador do Seafile.

      Login screen of the Seafile web interface

      Uma vez logado com sucesso, você pode acessar a interface de administração ou criar novos usuários.

      Agora que você verificou que a interface web está funcionando corretamente, você pode ativar esses serviços para iniciar automaticamente na inicialização do sistema no próximo passo.

      Passo 6 — Habilitando o Servidor Seafile para Iniciar na Inicialização do Sistema

      Para permitir que o servidor de arquivos e a interface web iniciem automaticamente na inicialização, você pode criar seus respectivos arquivos de serviço systemd e ativá-los.

      Crie um arquivo de serviço systemd para o servidor de arquivos Seafile:

      • sudo nano /etc/systemd/system/seafile.service

      Adicione o seguinte conteúdo ao arquivo:

      Create /etc/systemd/system/seafile.service

      [Unit]
Description=Seafile
After=network.target mysql.service

[Service]
Type=forking
ExecStart=/home/sammy/seafile/seafile-server-latest/seafile.sh start
ExecStop=/home/sammy/seafile/seafile-server-latest/seafile.sh stop
User=sammy
Group=sammy

[Install]
WantedBy=multi-user.target

      Aqui, as linhas ExecStart e ExecStop indicam os comandos que são executados para iniciar e parar o serviço Seafile. O serviço será executado com sammy como User e Group. A linha After especifica que o serviço Seafile será iniciado após o início da rede e do serviço MariaDB.

      Salve o seafile.service e saia.

      Crie um arquivo de serviço systemd para a interface web do Seahub:

      • sudo nano /etc/systemd/system/seahub.service

      Isso é semelhante ao serviço Seafile. A única diferença é que a interface web é iniciada após o serviço Seafile. Adicione o seguinte conteúdo a este arquivo:

      Create /etc/systemd/system/seahub.service

      [Unit]
Description=Seafile hub
After=network.target seafile.service

[Service]
Type=forking
ExecStart=/home/sammy/seafile/seafile-server-latest/seahub.sh start
ExecStop=/home/sammy/seafile/seafile-server-latest/seahub.sh stop
User=sammy
Group=sammy

[Install]
WantedBy=multi-user.target

      Salve o seahub.service e saia.

      Você pode aprender mais sobre arquivos de unidade do systemd no tutorial Understanding Systemd Units and Unit Files.

      Por fim, para permitir que os serviços Seafile e Seahub sejam iniciados automaticamente na inicialização, execute os seguintes comandos:

      • sudo systemctl enable seafile.service

      • sudo systemctl enable seahub.service

      Quando o servidor é reiniciado, o Seafile irá iniciar automaticamente.

      Neste ponto, você concluiu a configuração do servidor e agora pode testar cada um dos serviços.

      Passo 7 — Testando as Funcionalidades de Sincronização e Compartilhamento de Arquivos

      Neste passo, você testará a funcionalidade de sincronização e compartilhamento de arquivos do servidor que você configurou e garantirá que elas estejam funcionando corretamente. Para fazer isso, você precisará instalar o programa cliente do Seafile em um computador separado e/ou em um dispositivo móvel.

      Visite a página de download no site da Seafile e siga as instruções para instalar a versão mais recente do programa cliente no seu computador. Os clientes do Seafile estão disponíveis para as várias distribuições do Linux (Ubuntu, Debian, Fedora, Centos/RHEL, Arch Linux), MacOS e Windows. Clientes móveis estão disponíveis para dispositivos Android e iPhone/iPad nas respectivas lojas de aplicativos.

      Depois de instalar o cliente Seafile, você pode testar a funcionalidade de sincronização e compartilhamento de arquivos.

      Abra o programa cliente do Seafile no seu computador ou dispositivo. Aceite o local padrão para a pasta Seafile e clique em Next.

      Na próxima janela, digite o endereço do servidor, nome de usuário e senha e clique em Login.

      Na página inicial, clique com o botão direito do mouse em My Library e clique em Sync this library. Aceite o valor padrão para o local no seu computador ou dispositivo.

      Seafile client — Sync the default library

      Adicione um arquivo, por exemplo, um documento ou uma foto, na pasta My Library. Depois de algum tempo, o arquivo será carregado no servidor. A captura de tela a seguir mostra o arquivo photo.jpg copiado para a pasta My Library.

      Add a file to the default library from the computer

      Agora, efetue login na interface web em https://seu_domínio e verifique se seu arquivo está presente no servidor.

      My Library page to verify file sync

      Clique em Share ao lado do arquivo para gerar um link de download para esse arquivo que você pode compartilhar.

      Você verificou que a sincronização de arquivos está funcionando corretamente e que você pode usar o Seafile para sincronizar e compartilhar arquivos e pastas de vários dispositivos.

      Conclusão

      Neste tutorial, você configurou uma instância privada de um servidor Seafile. Agora você pode começar a usar o servidor para sincronizar arquivos, adicionar usuários e grupos e compartilhar arquivos entre eles ou com o público sem depender de um serviço externo.

      Quando uma nova versão do servidor estiver disponível, consulte a seção upgrade do manual para verificar os passos para executar uma atualização.



      Source link

      Forgot Your Password ?