One place for hosting & domains

      Arquivos

      Como usar o módulo pathlib para manipular os caminhos de sistema de arquivos no Python 3


      O autor selecionou a COVID-19 Relief Fund​​​​​ para receber uma doação como parte do programa Write for DOnations.

      Introdução

      O Python 3 inclui o módulo pathlib para manipular caminhos de sistema de arquivos de maneira independente, seja qual for o sistema operacional. O pathlib é semelhante ao módulo os.path, mas o pathlib oferece um nível mais elevado — e muitas vezes mais conveniente — de interface do que o os.path.

      Podemos identificar arquivos em um computador com caminhos hierárquicos. Por exemplo, podemos identificar o arquivo wave.txt em um computador com este caminho: /Users/sammy/ocean/wave.txt. Os sistemas operacionais representam caminhos de maneira ligeiramente diferente. O Windows pode representar o caminho para o arquivo wave.txt como C:Userssammyoceanwave.txt.

      O módulo pathlib pode ser útil para você se em seu programa Python você estiver criando ou movendo arquivos no sistema de arquivos, listando arquivos no sistema de arquivos em que todos correspondam a uma dada extensão ou padrão, ou criando caminhos de arquivo apropriados ao sistema operacional baseados em coleções de strings brutas. Embora seja possível usar outras ferramentas (como o módulo os.path) para realizar muitas dessas tarefas, o módulo pathlib permite que você execute essas operações com um alto grau de legibilidade e uma quantidade mínima de código.

      Neste tutorial, vamos revisar algumas das maneiras de usar o módulo pathlib para representar e manipular os caminhos de sistema de arquivos.

      Pré-requisitos

      Para tirar o máximo proveito deste tutorial, é recomendado ter alguma familiaridade com programação em Python 3. Você pode revisar esses tutoriais para as informações básicas necessárias:

      Construindo instâncias Path

      O módulo pathlib oferece várias classes, mas uma das mais importantes é a classe Path. As instâncias da classe Path representam um caminho para um arquivo ou diretório no sistema de arquivos do nosso computador.

      Por exemplo, o código a seguir cria uma instância Path que representa parte do caminho para um arquivo wave.txt:

      from pathlib import Path
      
      wave = Path("ocean", "wave.txt")
      print(wave)
      

      Se executarmos esse código, receberemos um resultado como o seguinte:

      Output

      ocean/wave.txt

      from pathlib import Path torna a classe Path disponível para nosso programa. Em seguida, Path("ocean", "wave.txt") cria uma nova instância do Path. Imprimir o resultado mostra que o Python adicionou o separador de sistema operacional / apropriado entre os dois componentes do caminho que demos a ele: "ocean" e "wave.txt".

      Nota: dependendo do seu sistema operacional, o resultado pode variar ligeiramente dos resultados de exemplo exibidos neste tutorial. Se estiver utilizando o Windows, por exemplo, seu resultado para este primeiro exemplo se pareceria com oceanwave.txt.

      Agora, o objeto Path atribuído à variável wave contém um caminho relativo. Em outras palavras, ocean/wave.txt pode existir em vários lugares em nosso sistema de arquivos. Para exemplificar, ele pode existir em /Users/user_1/ocean/wave.txt ou /Users/user_2/research/ocean/wave.txt, mas não especificamos exatamente a qual deles estamos nos referindo. Um caminho absoluto, por outro lado, refere-se sem sombra de dúvidas a uma localização específica no sistema de arquivos.

      Use o Path.home() para obter o caminho absoluto para o diretório home do usuário atual:

      home = Path.home()
      wave_absolute = Path(home, "ocean", "wave.txt")
      print(home)
      print(wave_absolute)
      

      Se executarmos esse código, receberemos um resultado parecido com o seguinte:

      Output

      /Users/sammy /Users/sammy/ocean/wave.txt

      Nota: como mencionado anteriormente, seu resultado irá variar dependendo do seu sistema operacional. Seu diretório home, por consequência, também será diferente de /Users/sammy.

      Path.home() retorna uma instância Path com um caminho absoluto para o diretório home do usuário atual. Em seguida, passamos essa instância Path e as strings "ocean" e "wave.txt" para outro construtor Path de forma a criar um caminho absoluto para o arquivo wave.txt. O resultado mostra que a primeira linha é o diretório home, e a segunda linha é o diretório home mais ocean/wave.txt.

      Este exemplo também ilustra uma característica importante da classe Path: o construtor Path aceita tanto strings quanto objetos Path pré-existentes.

      Vamos analisar as strings e objetos Path no construtor Path um pouco mais de perto:

      shark = Path(Path.home(), "ocean", "animals", Path("fish", "shark.txt"))
      print(shark)
      

      Se executarmos esse código Python, receberemos um resultado semelhante ao seguinte:

      Output

      /Users/sammy/ocean/animals/fish/shark.txt

      shark é um Path para um arquivo que construímos usando dois objetos Path (Path.home() e Path("fish", "shark.txt")) e as strings ("ocean" e "animals"). O construtor Path lida com os dois tipos de objetos de maneira inteligente e une-os corretamente usando o separador de sistema operacional adequado, neste caso, /.

      Acessando os atributos de arquivo

      Agora que aprendemos como construir instâncias Path, vamos analisar como você pode usar essas instâncias para acessar informações sobre um arquivo.

      Podemos usar os atributos name e suffix para acessar os nomes e sufixos dos arquivos:

      wave = Path("ocean", "wave.txt")
      print(wave)
      print(wave.name)
      print(wave.suffix)
      

      Ao executar este código, receberemos um resultado semelhante ao seguinte:

      Output

      /Users/sammy/ocean/wave.txt wave.txt .txt

      Este resultado mostra que o nome do arquivo no final do nosso caminho é wave.txt e o sufixo desse arquivo é .txt.

      As instâncias Path também oferecem a função with_name que permite criar rapidamente um novo objeto Path com um nome diferente:

      wave = Path("ocean", "wave.txt")
      tides = wave.with_name("tides.txt")
      print(wave)
      print(tides)
      

      Se executarmos o código acima, receberemos um resultado como o seguinte:

      ocean/wave.txt
      ocean/tides.txt
      

      Primeiro, o código constrói uma instância Path que aponta para um arquivo chamado wave.txt. Em seguida, chamamos o método with_name em wave para retornar uma segunda instância Path que aponta para um novo arquivo chamado tides.txt. A porção de diretório ocean/ do caminho permanece inalterada, deixando o caminho final como sendo ocean/tides.txt

      Acessando diretórios ancestrais

      Às vezes, é útil acessar diretórios que contêm um dado caminho. Vamos considerar um exemplo:

      shark = Path("ocean", "animals", "fish", "shark.txt")
      print(shark)
      print(shark.parent)
      

      Se executarmos esse código, receberemos um resultado parecido com o seguinte:

      Output

      ocean/animals/fish/shark.txt ocean/animals/fish

      O atributo parent em uma instância Path retorna o ancestral mais próximo de um determinado caminho de arquivo. Neste caso, ele retorna o diretório que contém o arquivo shark.txt: ocean/animals/fish.

      Podemos acessar o atributo parent várias vezes seguidas para percorrer a árvore de ancestralidade de um dado arquivo:

      shark = Path("ocean", "animals", "fish", "shark.txt")
      print(shark)
      print(shark.parent.parent)
      

      Se executarmos esse código, receberemos o seguinte resultado:

      Output

      ocean/animals/fish/shark.txt ocean/animals

      O resultado é semelhante ao resultado anterior, mas agora percorremos mais um nível acessando .parent uma segunda vez. Dois diretórios acima de shark.txt, você encontrará o diretório ocean/animals.

      Usando Glob para listar arquivos

      Também é possível usar a classe Path para listar arquivos usando o método glob.

      Suponha que tivéssemos uma estrutura de diretório que se parecia com esta:

      └── ocean
          ├── animals
          │   └── fish
          │       └── shark.txt
          ├── tides.txt
          └── wave.txt
      

      Um diretório ocean contém os arquivos tides.txt e wave.txt. Temos um arquivo chamado shark.txt contido no diretório ocean, um diretório animals e um diretório fish: ocean/animals/fish.

      Para listar todos os arquivos .txt no diretório ocean, podemos utilizar:

      for txt_path in Path("ocean").glob("*.txt"):
          print(txt_path)
      

      Esse código produziria um resultado como este:

      Output

      ocean/wave.txt ocean/tides.txt

      O padrão glob "*.txt" encontra todos os arquivos terminados em .txt. Como a amostra de código executa esse glob no diretório ocean, ela retorna os dois arquivos .txt no diretório ocean: wave.txt e tides.txt.

      Nota: se você quiser replicar os resultados mostrados neste exemplo, você precisará imitar a estrutura de diretórios aqui ilustrada em seu computador.

      Também podemos usar o método glob recursivamente. Para listar todos os arquivos .txt no diretório ocean e todos os seus subdiretórios, podemos utilizar:

      for txt_path in Path("ocean").glob("**/*.txt"):
          print(txt_path)
      

      Se executarmos esse código, receberemos um resultado como o seguinte:

      Output

      ocean/wave.txt ocean/tides.txt ocean/animals/fish/shark.txt

      A parte ** do padrão glob irá corresponder a esse diretório e todos os diretórios abaixo dele, recursivamente. Dessa forma, não só temos os arquivos wave.txt e tides.txt no resultado, mas também recebemos o arquivo shark.txt que estava contido em ocean/animals/fish.

      Computando caminhos relativos

      Podemos usar o método Path.relative_to para computar caminhos em relação uns aos outros. O método relative_to é útil quando, por exemplo, você quiser recuperar parte de um caminho de arquivo longo.

      Considere o código a seguir:

      shark = Path("ocean", "animals", "fish", "shark.txt")
      below_ocean = shark.relative_to(Path("ocean"))
      below_animals = shark.relative_to(Path("ocean", "animals"))
      print(shark)
      print(below_ocean)
      print(below_animals)
      

      Se executarmos o código acima, receberemos um resultado como o seguinte:

      Output

      ocean/animals/fish/shark.txt animals/fish/shark.txt fish/shark.txt

      O método relative_to retorna um novo objeto Path relativo ao argumento dado. Em nosso exemplo, computamos o Path para o shark.txt relativo ao diretório ocean, e então relativo tanto ao diretório ocean quanto ao diretório animals.

      Se relative_to não puder computar uma resposta porque lhe fornecemos um caminho não relacionado, ele gera um ValueError:

      shark = Path("ocean", "animals", "fish", "shark.txt")
      shark.relative_to(Path("unrelated", "path"))
      

      Receberemos uma exceção ValueError gerada a partir deste código que será algo parecido com isto:

      Output

      Traceback (most recent call last): File "<stdin>", line 1, in <module> File "/usr/local/lib/Python3.8/pathlib.py", line 899, in relative_to raise ValueError("{!r} does not start with {!r}" ValueError: 'ocean/animals/fish/shark.txt' does not start with 'unrelated/path'

      unrelated/path não faz parte de ocean/animals/fish/shark.txt, então não existe nenhuma maneira para o Python computar um caminho relativo.

      Conclusão

      O módulo pathlib é uma parte poderosa da Biblioteca Padrão do Python que nos permite manipular caminhos do sistema de arquivos rapidamente em qualquer sistema operacional. Neste tutorial, aprendemos a usar alguns utilitários chave do pathlib para acessar atributos de arquivo, listar arquivos com padrões glob e percorrer arquivos e diretórios pais.

      O módulo pathlib também oferece classes e utilitários adicionais que não abordamos neste tutorial. Agora que você tem um conhecimento base, use a documentação do módulo pathlib para aprender mais sobre outras classes e utilitários disponíveis.

      Se estiver interessado em usar outras bibliotecas do Python, confira os seguintes tutoriais:



      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