Network File System (NFS) é um protocolo de sistema de arquivos sobre rede e permite compartilhamento de pastas e arquivos entre computadores.
Ele é consideravelmente mais simples que o Server Message Block (SMB), protocolo usado pelo Windows para compartilhamento de pastas e impressoras, de forma que não possui qualquer suporte a autenticação de usuário ou criptografia. O controle de acesso é feito por endereço IP e pelas permissões do próprio sistema de arquivos.
Ele tem como objetivo ser simples e transparente para aplicações de forma que pareça fazer parte do sistema de arquivos no cliente, enquanto mantém um bom desempenho.
Esse protocolo existe nativamente em sistemas tipo Unix, como Linux, macOS e FreeBSD. No Windows, o suporte ao protocolo precisa ser adicionado como um pacote extra, mas é oferecida pela própria Microsoft.
Em servidores Debian, Ubuntu ou derivados, instale o servidor NFS com:
# apt install nfs-kernel-server
Crie a pasta a ser exportada e defina as permissões adequadas – Proxmox vai escrever como root no sistema de arquivos exportado:
O servidor NFS usa a opção root_squash por padrão na configuração, que mapeia as escritas do root do cliente para a uid e gid de um usuário de privilégio mais baixo no sistema. Escrita e leitura de outros usuários não são afetadas e levam a mesma uid e gid que o usuário do cliente.
Edite o arquivo /etc/exports para adicionar a pasta a ser exportada, o IP do cliente que vai acessá-la e os parâmetros de configuração da exportação:
/pmx-backup 192.168.0.2(rw,sync,no_subtree_check)
E então exporte os sistemas de arquivos configurados:
# exportfs -ar
Abra a porta para o NFSv4 (essa versão requer apenas a porta 2049/tcp):
# ufw allow proto tcp from 192.168.0.2 to any port 2049
Onde 192.168.0.2 é o IP do servidor Proxmox.
Para configurar o armazenamento no Proxmox, vá em Datacenter > Storage > Add > NFS e preencha com as informações necessárias:
Sendo uma alternativa ao ambiente Microsoft, o Google Workspace também conta com um serviço de diretório. O LDAP seguro pode ser usado para autorização e autenticação de usuários. O FreeRADIUS foi usado para implementar autenticação WPA2-Enterprise na rede Wi-Fi, com um detalhe: a autenticação precisava funcionar para 2 domínios de e-mail diferentes, de dois ambientes Google Workspace independentes.
Enquanto a autenticação com AD no FreeRADIUS é feita através do método de desafio e resposta, MSCHAPv2, o LDAP seguro do Google não implementa esse protocolo e precisa que a senha do usuário seja enviada em texto pleno dentro de um túnel SSL. Isso pode ser feito com a combinação de protocolos EAP-TTLS/PAP. Diferente do EAP-TLS, que exige o par de certificado/chave tanto do cliente quanto do servidor, o EAP-TTLS exige o par apenas do servidor.
O servidor utilizado foi o Ubuntu 24.04 mas o processo serve também para outras versões. Primeiro passo é criar o cliente LDAP no Google Workspace. No console de administrador, vá em Apps > LDAP > Adicionar Cliente
Atribua as permissões necessárias para o cliente:
Em seguida, baixe os certificados e ative o serviço.
Agora, preparando o servidor FreeRADIUS:
# apt install freeradius freeradius-ldap
Diferente do CentOS, o Ubuntu já gera os certificados pro TLS automaticamente no processo de instalação.
Transfira o par de certificado/chave baixado do Google Workspace para o servidor, armazenando-os em /etc/freeradius/3.0/certs/google/, onde já é esperado pelo FreeRADIUS nas configurações a se seguir.
Partindo para os arquivos de configuração, a começar pelo LDAP, fazendo uma cópia do arquivo para cada ambiente Workspace:
# cp -a /etc/freeradius/3.0/mods-available/{ldap_google,ldap_workspace0}
# cp -a /etc/freeradius/3.0/mods-available/{ldap_google,ldap_workspace1}
Edite o arquivo, adicionando ou alterando as linhas:
Caso tenha alterado os certificados a serem usados, você também vai precisar editar as configurações referentes a isso no bloco de configurações comuns de TLS.
Você pode comentar outros módulos não utilizados, como TLS, PEAP e MSCHAPv2, deixando apenas as configurações comuns de TLS e o bloco do TTLS.
O arquivo /etc/freeradius/3.0/sites-enabled/default tem diversas opções, muitas podem (e devem) ser desabilitadas. Edite os blocos authorize e authenticate para que fiquem como abaixo:
No arquivo /etc/freeradius/3.0/sites-enabled/inner-tunnel, edite os mesmos blocos, adicionando a condicional para os dois domínios:
server inner-tunnel {
authorize {
filter_username
if ("%{User-Name}" =~ /@dominio0\.com$/) {
ldap_workspace0
update control {
Auth-Type := ldap_workspace0
}
} elsif ("%{User-Name}" =~ /@dominio1\.com$/) {
ldap_workspace1
update control {
Auth-Type := ldap_workspace1
}
} else {
reject
}
expiration
logintime
}
authenticate {
Auth-Type ldap_workspace0 {
ldap_workspace0
}
Auth-Type ldap_workspace1 {
ldap_workspace1
}
Auth-Type PAP {
pap
}
}
}
Terminando a edição dos arquivos, você deve reiniciar o serviço para que as configurações tenham efeito, garantindo antes que todos os arquivos pertencem ao usuário e grupo freerad.
Nextcloud tem suporte a diferentes tipos de armazenamentos externos através do app “External storage support”, entre eles: SMB (compartilhamento de pasta do Windows), SFTP e Amazon S3.
Amazon Simple Storage Service (S3) é um serviço de armazenamento de objetos, que se diferencia do armazenamento de arquivos em alguns aspectos. Um deles sendo que, enquanto que em armazenamento de arquivos existe uma hierarquia de pastas ou diretórios, no armazenamento de objetos eles se encontram todos no mesmo ambiente, chamado bucket.
Aplicações conseguem, no entanto, simular essa estrutura de pastas, graças ao fato de que o caractere / é permitido no nome dos objetos. E é exatamente isso que acontece no Nextcloud e no utilitário de linha de comando aws.
A forma como o armazenamento de objetos é construído permite uma alta escalabilidade e, diferente de um serviço de armazenamento de arquivos como Google Drive, em que você contrata uma quantidade de armazenamento para ter disponível, nos serviços de armazenamento de objetos você paga pelo que é usado.
Esse tipo de serviço é comumente usado em cenários de armazenamento de grande escala, como backups, CDNs, dados para treinamento de LLMs como ChatGPT e Gemini, onde não há necessidade de edição de arquivos no armazenamento.
Partindo para a prática, o bucket foi criado de forma simples, mantendo as opções padrões:
Agora deve-se criar um usuário, um grupo, adicionar o usuário ao grupo e criar uma política para dar acesso ao bucket para o usuário. Isso pode ser feito através do console:
Você pode permitir acesso do grupo ao bucket através da política de permissão existente AmazonS3FullAccess. Isso daria acesso a todos os buckets existentes na conta para esse grupo. Isso pode não ser desejável. Uma alternativa é criar uma política de permissão, que pode ser feita no formato json:
Verificado o funcionamento, basta configurar no Nextcloud: habilite o aplicativo “External storage support” e ajuste as configurações de acordo com as preferências.
O host foi um pouco difícil de descobrir, não encontrei na AWS de forma tão explícita. Em vez disso, ao selecionar um objeto existente no bucket (que fiz upload com o utilitário de linha de comando), aparecia a opção de copiar URL, e foi como vi que o endereço era: s3.<região da AWS>.amazonaws.com
Ao conectar, o armazenamento S3 aparece como uma pasta para os usuários que você determinar. Adicionalmente, é possível permitir que usuários adicionem armazenamentos externos, como o S3, para as próprias contas.
Um dia o nginx que configurei como proxy reverso aqui passou a dar timeout ao tentar carregar o Nextcloud. Ao investigar, verifiquei que mesmo ao fazer a solicitação ao servidor Nextcloud a partir do próprio servidor que hospeda o nginx/OpenVPN, através do comando abaixo, a solicitação não completava.
$ curl -v http://10.8.0.3
As solicitações feitas dentro da LAN funcionavam, indicando que o problema acontecia apenas dentro da VPN. No entanto, dentro da VPN o ping funcionava, solicitações para outras páginas do Nextcloud também funcionavam, como:
$ curl -v http://10.8.0.3/status.php
Tentei aprofundar a investigação mas eu não sou nenhum especialista em redes, só um entusiasta que se mete profissionalmente. Uma explicação que consegui foi que o problema podia ser relacionado ao MTU (maximum transmission unit) da interface virtual de rede do OpenVPN.
Tanto a interface virtual do OpenVPN (tun0) quanto a interface de rede da máquina (eth0) possuíam o mesmo MTU: 1500 bytes. Isso pode ser verificado com:
$ ip a
Diminui o MTU do tun0 para 1380, tanto no servidor quanto no cliente, que foi uma sugestão que encontrei e funcionou. Esqueci o problema até acontecer com outra instalação do Nextcloud que mantenho. Mesmo problema, mesma solução. Eventualmente retornei o MTU pra 1500 e continuou funcionando.
O blog não existia na época da primeira ocorrência com o Nextcloud. Agora, tive o mesmo problema com o WordPress e o novo Nextcloud. E o problema parece inconsistente. Tudo funciona, até que de repende para. E em momentos diferentes, sem nenhum gatilho claro, mas claramente alguma tentativa de enviar um pacote maior que não poderia ser fragmentado falhou.
Dessa vez parei pra investigar um pouco melhor. Já que o MTU da tun0 é 1500, um ping com tamanho de 1472 bytes (-20 do cabeçalho IP -8 do cabeçalho ICMP) deve passar sem ser fragmentado. Não passou. 100% dos pacotes perdidos. Fui baixando até encontrar o ponto onde os pings tem resposta: 1396 bytes. MTU de 1424 bytes.
Testei então: ping sem opções definidas e com tamanhos 1396 e 1397 bytes, monitorando também com o tcpdump tanto no servidor quanto no cliente:
$ ping 10.8.0.3
$ ping -M do -s 1396 10.8.0.3
$ ping -M do -s 1397 10.8.0.3
Para o tcpdump:
# tcpdump -i tun0 icmp
Resultados:
“ping 10.8.0.3” e “ping -M do -s 1396 10.8.0.3”:
pra cada 10 pings, 0% de perda de pacotes.
tcpdump reporta 20 pacotes capturados tanto no servidor quanto no cliente: solicitação e resposta
Ótimo. Agora:
“ping -M do -s 1397 10.8.0.3” e valores acima:
pra cada 10 pings, 100% de perda de pacotes
tcpdump reporta 10 pacotes capturados no servidor, 20 no cliente: o pacote sai do servidor e chega ao cliente, que responde, mas as respostas do cliente não chegam ao servidor.
O mesmo foi feito pingando do cliente para o servidor. Mesmo sucesso para pacotes de 1396 bytes e menores. Já com
ping -M do -s 1397 10.8.0.1:
pra cada 10 pings, 100% de perda de pacotes
tcpdump reporta 10 pacotes capturados no cliente, 0 no servidor.
Ou seja, o problema está no envio de pacotes dos clientes para o servidor através do túnel.
O ping não alerta que o pacote é grande demais nem dá qualquer erro específico, apenas para pings com tamanho acima de 1472 (que resultariam num pacote acima do MTU). Em vez disso, apenas falha silenciosamente.
Adicionalmente ao ping, fiz testes com requisições às páginas que resultavam em timeout usando curl e monitorando com tcpdump.
Solução: baixar o valor do MTU da interface tun0 do servidor e clientes da VPN para 1424 bytes: tamanho total do maior pacote do ping que funcionou (1396 de payload, 20 do cabeçalho IP e 8 do cabeçalho ICMP).
Isso pode ser feito de forma não persistente com:
# ip link set dev tun0 mtu 1424
O MTU vai voltar para 1500 quando o serviço do OpenVPN for reiniciado. Para configurar de forma persistente, inclua essa linha nos arquivos de configuração do OpenVPN do servidor e dos clientes:
tun-mtu 1424
Eu ainda não entendi 100% o que causa esse problema e ele não parece afetar todos os clientes igualmente ou ao mesmo tempo. O servidor recebia resposta do ping com payload de 1472 de alguns clientes sem problemas, que exibiam a página e operavam com a MTU padrão de 1500 bytes no tun0.
Até então, após a mudança para o MTU de 1424, o problema não reincidiu. Sendo mais conservador, eu colocaria um valor mais baixo, pra deixar uma margem pra possíveis alterações que possam vir a acontecer no OpenVPN ou nos outros servidores, masss eu tô aqui pra ver o que acontece.
Docker é uma ferramenta que permite a distribuição de softwares em contêineres, ambientes de execução independentes. Algo como máquinas virtuais, mas sem o mesmo overhead da virtualização de hardware e sem necessidade de outro kernel sendo executado.
Isso permite que os desenvolvedores tenham um maior controle sobre versões de dependências como bibliotecas e outros programas com que o software interage, independente da distribuição Linux onde o software vai ser executado.
Isso também facilita a implantação, já que muita coisa no ambiente não precisará ser configurada após a instalação.
Portainer é uma ferramenta para gerenciamento e monitoramento de contêineres Docker, podendo também gerenciar Podman e Kubernetes. É distribuído também como um contêiner Docker.
Começando pela instalação do Docker pelas fontes oficiais, nesse caso para o Ubuntu Server 24.04, é necessário primeiro importar a chave do repositório do Docker:
O parâmetro -p é usado para mapear uma porta do host para uma porta do contêiner – docker usa iptables e isso pode contornar o firewall do sistema operacional.
O parâmetro -v é usado para mapear um volume docker ou um /caminho/no/seu/sistema para um caminho dentro do contêiner.
A porta 9443 é usada para acesso à interface web via HTTPS. Por padrão são gerados certificados autoassinados e, enquanto é possível especificar seus certificados já no comando “docker run”, também é possível alterá-los pelas configurações na própria interface web.
A porta 8000 é usada pela funcionalidade Edge computing, que permite gerenciamento e implantação de contêineres em dispositivos remotos através de um túnel TCP.
Verifique que o Portainer está sendo executado com:
$ docker ps
Então, acesse-o pelo navegador através da porta 9443 com protocolo HTTPS e siga a configuração pela página web.
Hora de instalar um contêiner: existem alguns templates mas a seção Containers permite que qualquer imagem seja baixada do Docker Hub e o contêiner construído a partir dela, com os parâmetros de configuração escolhidos.
Um software interessante que é distribuído como um contêiner docker é o Metabase: uma plataforma livre e aberta para análise de dados e Business Intelligence.
De acordo com o site oficial, a instalação como contêiner docker pode ser feita pelo seguinte comando:
$ docker run -d -p 3000:3000 --name metabase metabase/metabase
O que, pelo Portainer, fica:
Após inicializado, basta acessar o servidor na porta 3000 via HTTP.
O comando “docker run” é tipicamente usado para softwares ou sistemas que são distribuídos como um único contêiner. Alguns sistemas são compostos de múltiplos contêineres que trabalham em conjunto.
Nesses casos, em vez de usar o comando “docker run” passando os parâmetros de configuração como argumentos, o comando “docker compose” é usado com um arquivo docker-compose.yml que armazena esses parâmetros de configuração. A configuração do Metabase nesse formato, por exemplo, ficaria:
Outro sistema interessante de ser instalado é o GLPI: um sistema de gerenciamento de Helpdesk e ativos de TI. A instalação usa um arquivo docker-compose.yml, que pode ser encontrado no Docker Hub: https://hub.docker.com/r/glpi/glpi, e especifica dois contêineres: um com o GLPI empacotado com o servidor web e PHP e outro com o banco de dados MySQL. O exemplo abaixo teve alguns parâmetros adaptados:
Como a configuração especifica um arquivo com variáveis de ambiente, também precisamos dele, o stack.env, com o conteúdo abaixo.
O Portainer espera que o arquivo seja especificado com esse nome no yml, porque é o nome do arquivo que ele forma a partir das variáveis que são fornecidas. O arquivo para upload pode ter qualquer nome.
Todas as variáveis estão no stack.env. O Portainer não resolve variáveis no arquivo .yml, então todas precisam ser especificadas no stack.env ou no próprio .yml. Isso levou a variáveis com valores redundantes no stack.env
Pela mesma questão acima, o teste do banco de dados foi removido.
Volumes docker foram especificados em vez de caminhos para pastas no host.
Para uma implantação desse tipo no Portainer, vá na seção Stacks. Lá é possível fazer upload dos arquivos ou colar o conteúdo no editor web.
O GLPI leva um tempo após a inicialização do contêiner para ser instalado e ficar disponível na porta mapeada, nesse caso 8080. O MySQL gera uma senha aleatória para o usuário root, que você pode obter com:
Voltando ao Metabase: a implantação do Metabase abordada armazena as configurações em um banco de dados H2, no volume do próprio contêiner, sem nenhum volume persistente configurado. Ou seja, ao fazer uma atualização – que é feita por remover e adicionar um novo contêiner, todas as configurações, dashboards e conexões com bancos de dados seriam excluídos.
Para uso em produção, o metabase precisa ser combinado com um banco de dados para produção, como PostgreSQL. Abaixo, um exemplo de configuração em formato .yml para implantação:
Rustdesk é um software de acesso e controle remoto para Windows, macOS e Linux, tendo também aplicativos para Android e iOS.
O cliente, ao ser instalado, irá por padrão usar um servidor público gratuito. Você provavelmente não vai querer isso, principalmente por questão de desempenho, já que o público tem uma latência considerável.
O lado do servidor possui duas edições: uma comercial e uma da comunidade. A edição da comunidade tem algumas limitações, a mais notável sendo a ausência da capacidade própria de gerenciamento de dispositivos. Enquanto a comercial tem uma licença proprietária, a da comunidade é distribuída sob a licença AGPL-3.0.
O download pode ser feito na página do projeto no GitHub. Para os componentes do servidor:
O cliente tem uma instalação bem direta para qualquer sistema operacional.
O servidor é composto de dois serviços:
rustdesk-hbbs – É o servidor de ID (rendezvous/sinalização). O papel dele é identificar os dois dispositivos a serem conectados e fazê-los criar uma conexão P2P mesmo através de um firewall ou NAT, através da técnica de “hole punching”, de forma que após estabelecida, a conexão não depende da atuação do servidor.
rustdesk-hbbr – Dependendo das configurações da rede em que os dois dispositivos se encontram, nem sempre é possível estabelecer uma conexão P2P. Nesse caso, o hbbr assume como um relay, com a comunicação entre os dois dispositivos sendo mediada por ele.
Para instalar, basta baixar os pacotes adequados pra arquitetura do seu servidor na seção releases da página do Rustdesk no GitHub e instalá-los no servidor – que deve ser Debian ou Ubuntu, já que apenas pacotes .deb são distribuídos oficialmente.
A instalação completa consiste em três pacotes, dois sendo os serviços mencionados e outro como um utilitário pra configuração e teste do Rustdesk.
$ systemctl status rustdesk-hbbs
$ systemctl status rustdesk-hbbr
Configure o seu firewall: o serviço rustdesk-hbbs escuta nas portas 21115/tcp e 21116/(tcp+udp), e o rustdesk-hbbr na porta 21117/tcp, então:
# ufw allow 21115:21117/tcp
# ufw allow 21116/udp
A instalação gera alguns arquivos em /var/lib/rustdesk-server: um par de chaves público-privada e alguns arquivos de banco de dados SQLite, usado para armazenamento de informações de clientes.
O par de chaves é gerado automaticamente na instalação e, caso queira, você pode gerar novas com:
$ rustdesk-utils genkeypair
e substituir nos arquivos id_ed25519.pub e id_ed25519. Reinicie os serviços para que tenha efeito.
A chave pública é necessária para a configuração dos clientes.
No cliente instalado, vá nas configurações > Rede > Servidor de ID/Relay e especifice seu endereço de IP ou nome de domínio para ambos os servidores e sua chave pública – que você pode não querer que seja tão pública.
Nenhuma das publicações sobre instalação de WordPress ou Nextcloud aborda acesso via HTTPS ou certificados SSL, apenas HTTP.
Acontece que isso é centralizado em uma instalação do nginx, atuando como proxy reverso. O servidor que hospeda o nginx e o servidor de OpenVPN são a mesma máquina: um VPS com 512mb de RAM e 1vCPU.
O nginx recebe as requisições em HTTPS e as encaminha em HTTP* de forma segura para os outros servidores – clientes da VPN: WordPress, Nextcloud e Proxmox – 3 máquinas diferentes.
* Proxmox usa HTTPS por padrão mas com um certificado verificado por uma CA interna
Vantagens:
só é necessário gerenciar os certificados em um servidor, independente de quantos sites são.
as 3 máquinas diferentes poderiam estar em qualquer rede, qualquer lugar – isso é, se não fossem virtualizadas dentro do Proxmox, podendo até ser uma rede residencial que bloqueia tráfego de entrada (muito obrigado, Claro), basta se conectar na VPN.
Desvantagem:
existe um pouco de latência devido à distância entre as máquinas (Rio de Janeiro) e o VPS (São Paulo).
Ainda que fosse possível abrir as portas na rede e o OpenVPN não fosse necessário, usar o nginx como um proxy reverso na mesma LAN ainda poderia ser vantajoso pelo o gerenciamento centralizado dos certificados SSL, logs de acesso e uso de múltiplos nomes de domínio em diferentes servidores pro mesmo IP na mesma porta.
Os arquivos de configuração do nginx para cada site devem ficar localizados em /etc/nginx/sites-available e para habilitá-los basta criar um symlink em /etc/nginx/sites-enabled com:
A primeira configuração recomendada é para receber a solicitação HTTP na porta 80 e redirecionar o cliente para fazer uma solicitação HTTPS na porta padrão 443.
Em todos os exemplos de configuração abaixo, substitua o nome do servidor (FQDN), o caminho para o certificado e chave SSL e o IP privado para onde deve ser encaminhada a solicitação.
Como mencionado, é possível usar a mesma porta para todos os servidores, como a porta padrão HTTPS, desde que cada um tenha o parâmetro server_name diferente, cada um com um nome de domínio (FQDN).
Sugestão de configuração adicional para o WordPress – o WordPress não tem um mecanismo de proteção contra tentativas de acesso por força bruta. Para mitigar isso, além de usar boas senhas, você pode limitar o acesso por IP às localizações /wp-admin e /wp-login.php na configuração do proxy reverso adicionando essa configuração:
server {
location ~* ^/(wp-admin|wp-login.php) {
allow 186.205.1.165; # seu IP de casa
allow 191.252.110.50; # seu IP do trabalho
deny all;
proxy_pass http://10.8.0.4;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
}
}
Por conveniência, você também pode fazer o nginx escutar pra solicitações a HTTP na porta 80 e redirecionar todos os clientes para uma solicitação HTTPS:
Caso ainda não tenha certificados SSL válidos, eles podem ser obtidos gratuitamente com a Let’s Encrypt, uma organização sem fins lucrativos, com o comando certbot. Primeiro, pare o serviço nginx, já que o certbot vai criar um processo que também vai escutar na porta 80. Então, use o comando nesse formato:
Nextcloud é uma solução de armazenamento de arquivos acessível via web, como Google Drive, que conta também com aplicativos de calendário, contatos, mensagens e chamadas de vídeo, cliente de e-mail e suporte a compartilhamento de arquivos. Também tem suporte a integração de suíte office, através do ONLYOFFICE ou Nextcloud Office (baseado no LibreOffice).
Além disso, Nextcloud trás também o conceito de federação: instâncias distintas do Nextcloud podem se comunicar se assim os administradores quiserem, permitindo uma rede descentralizada de servidores, onde um usuário de uma instância pode se comunicar e compartilhar arquivos com um usuário de outra.
É software livre e aberto, licenciado sob a AGPLv3, e conta também com planos empresariais.
No momento os sistemas recomendados para o Nextcloud são Ubuntu 24.04 e RHEL 9, mas tem suporte também a outros como OpenSUSE, Debian e Alpine. Aqui vamos usar o Ubuntu 24.04.
O Nextcloud precisa de: um servidor web, um banco de dados e PHP. Eu segui a instalação com Apache pro servidor web e PostgreSQL pro banco de dados.
Outras alternativas suportadas são Nginx para o servidor web e MySQL e MariaDB para o banco de dados.
Instalação e configuração do Apache com PHP:
# apt install apache2 php
Caso tenha habilitado o firewall (Ubuntu traz o UFW desabilitado por padrão), permita o acesso por http:
# ufw allow http
Visite o seu servidor web via http e verifique que o Apache funciona. Coloque um arquivo como index.php na pasta do servidor web /var/www/html com o conteúdo
<?php phpinfo() ?>
e visite sua página no local /index.php para verificar que o Apache está processando PHP.
Instalando e configurando o banco de dados:
# apt install postgresql
# sudo -u postgres psql
Isso vai te levar à linha de comando do PostgreSQL, onde você pode criar o usuário e o banco de dados a ser usado no Nextcloud:
> CREATE USER nextcloud_operator WITH PASSWORD 'senhaNoPost-it';
> CREATE DATABASE nextcloud_db WITH OWNER nextcloud_operator TEMPLATE template0 ENCODING 'UTF8';
> \q
Extraia o arquivo .zip na pasta /var/www. Você vai ver uma pasta nextcloud. Mude o proprietário dela e dos arquivos e subpastas para o usuário www-data, que executa o Apache:
# chown -hR www-data:www-data /var/www/nextcloud
Edite o arquivo de configuração do Apache, /etc/apache2/sites-enabled/000-default.conf para alterar/adicionar as seguintes configurações:
DocumentRoot /var/www/nextcloud
<Directory /var/www/nextcloud/>
Require all granted
AllowOverride All
Options Indexes FollowSymLinks MultiViews
<IfModule mod_dav.c>
Dav off
</IfModule>
</Directory>
Instale outros módulos PHP necessário para o Nextcloud:
Sugestão de configuração adicional: os arquivos de usuários ficam na pasta /var/www/nextcloud/data, dentro da pasta raiz do Nextcloud. No caso de um bug num dos scripts PHP ou no servidor web, arquivos privados poderiam ser expostos. Então você pode querer configurar a pasta data em outro local, fora da raiz /var/www do servidor web, como por exemplo /var/nextcloud_data.
Essas e outras questões menos críticas de configuração são abordadas também na documentação oficial do Nextcloud.
O acesso via HTTPS será feito utilizando o servidor web Nginx atuando como proxy reverso, abordado em outra postagem.
RADIUS é um protocolo de rede que oferece gerenciamento centralizado de autorização e autenticação para acesso de usuários a serviços de rede. Muito usado, por exemplo, como uma alternativa mais segura de acesso a uma rede Wi-Fi, onde cada usuário usa suas credenciais para se conectar, em vez de todos compartilharem uma única senha.
FreeRADIUS é um sistema livre e aberto que implementa esse protocolo e pode ser configurado pra usar diferentes back-ends para autorização e autenticação, um deles é o Active Directory.
Pra configurar esse sistema, garanta antes que o servidor RADIUS possa encontrar e ingressar no domínio – aqui tratado como exemplo.com:
Domínio e o controlador de domínio podem ser encontrados por consulta de DNS e são acessíveis na rede.
O arquivo /etc/hosts do servidor deve conter o FQDN especificado, algo como:
Após isso, instale e configure o Samba, que vai ser usado para ingressar o computador no domínio. A partir daqui, as instruções são válidas para sistemas da família Red Hat, tendo sido usado o CentOS Stream 9.
# dnf install samba
Adapte a configuração abaixo para o seu domínio, alterando ou adicionando os seguintes parâmetros no arquivo /etc/samba/smb.conf :
Agora que o servidor já faz parte do domínio e conseguimos autenticar usuários com ntlm_auth, podemos instalar os pacotes do FreeRADIUS para então configurá-lo
# dnf install freeradius freeradius-utils
Pra autenticação no AD, vamos usar a combinação de protocolos PEAP/MSCHAPv2.
Edite a o módulo mschap localizado em /etc/raddb/mods-enabled/mschap para alterar as seguintes configurações
Edite o módulo eap localizado em /etc/raddb/mods-enabled/eap para alterar a seguinte configuração:
eap {
default_eap_type = peap
}
Dica: os arquivos de configuração do FreeRADIUS são extensivamente comentados. Isso é ótimo porque ajuda a entender a configuração já na hora. Mas se quiser ver só a configuração, sem os comentários e linhas em branco:
Na pasta /etc/raddb/certs, execute o arquivo bootstrap para gerar os certificados necessários para o TLS usado no PEAP.
Adicione o usuário radiusd ao grupo wbpriv para que o FreeRADIUS tenha acesso para ler a resposta do winbind à solicitação de autenticação, através do socket em /var/lib/samba/winbindd_privileged/pipe
Você pode testar a autenticação pelo FreeRADIUS com
radtest -t mschap daniel senhaqueanoteinoblocodenotas localhost 0 testing123
e configurar outros clientes do FreeRADIUS em /etc/raddb/clients.conf
Alguns clientes podem não aceitar o certificado gerado com as configurações padrão do FreeRADIUS, então é recomendado ajustar as configurações pra que o certificado seja emitido corretamente para o FQDN do servidor. O Easy RSA também pode ajudar a gerar e manter os certificados.
OpenVPN é um sistema de rede virtual privada (VPN), usado pra criar conexões seguras entre dispositivos, protegendo a troca de informações mesmo em trajetos não confiáveis, como a internet. Implementa tanto aplicação de servidor quanto de cliente e é distribuído sob a licença GPL-2.0.
O sistema funciona com base em infraestrutura de chave pública (PKI). Pra configurar a autenticação de forma segura é necessário gerar certificados SSL e chaves para uma autoridade certificadora (CA), para o servidor e para os clientes da VPN.
Felizmente, não precisamos tocar diretamente no OpenSSL, que é bem complexo. Em vez disso, a gente usa o EasyRSA, uma ferramenta que nos ajuda a gerar as chaves e certificados que a gente precisa.
Considerando uma instalação do Debian ou Ubuntu server:
# apt install openvpn easy-rsa
Pra facilitar e deixar a configuração organizada, copie a pasta do EasyRSA para dentro da pasta de configuração do OpenVPN.
# cp -r /usr/share/easy-rsa /etc/openvpn/
Vá para a pasta /etc/openvpn/easy-rsa, edite copie o arquivo vars.example como var e descomente as linhas que quiser editar de acordo com a sua preferência. Configurações sugeridas:
Dessa forma, os certificados serão válidos por 2 anos, a lista de revogação de certificados (CRL) por 1 ano, e todos os certificados vão ser emitidos com validade fixa a partir de 30 de Janeiro.
Após configurado, podemos iniciar nossa PKI e gerar o CA:
# bash easyrsa init-pki
# bash easyrsa build-ca
Ao gerar a chave do CA, uma senha será pedida pra criptografar a chave do CA.
Deve-se também gerar a chave de Diffie-Hellman, que é usada para gerar a chave simétrica da conexão de VPN a ser estabelecida.
# bash easyrsa gen-dh
Opcionalmente, para maior segurança, pode-se gerar uma chave de autenticação para que o servidor exija uma assinatura válida nos pacotes recebidos dos clientes.
# openvpn --genkey secret pki/tls-auth.key
Ao gerar o par de chaves do servidor, é uma boa ideia gerar a chave sem senha pra que o serviço possa ser iniciado junto com o sistema:
Agora, a configuração do servidor e dos clientes vai depender do propósito da VPN: pode ser um gateway, pode ser apenas para conectar um cliente ao outro, pode ser pra conectar clientes à uma LAN.
Crie um arquivo com extensão .conf na pasta /etc/openvpn server, como por exemplo config_do_servidor.conf com esse conteúdo de exemplo – adapte-o para a sua necessidade:
# Configurações da conexão
# Descomente a linha abaixo e coloque o IP do seu servidor caso ele esteja dentro de uma LAN
;local 192.168.0.10
port 1194
proto udp4
dev tun0
keepalive 10 120
persist-key
persist-tun
# As linhas abaixo determinam a rede privada que seu servidor vai criar
server 10.8.0.0 255.255.255.0
topology subnet
push "route 10.8.0.0 255.255.255.0"
# Descomente a linha abaixo e substitua a LAN pela sua caso queira que os clientes tenham uma rota para a LAN do servidor
;push "route 192.168.0.0 255.255.255.0"
# Descomente a linha abaixo caso queira que o cliente use o servidor de VPN como gateway
;push "redirect-gateway def1 bypass-dhcp"
# Configura resolvedores de DNS alternativos
;push "dhcp-option DNS 208.67.222.222"
;push "dhcp-option DNS 208.67.220.220"
# Permite que clientes da VPN possam alcançar outros
;client-to-client
# Limita o número de clientes na VPN
;max-clients 5
# Configurações do processo
verb 3
explicit-exit-notify 1
status /var/log/openvpn/status-conext00.log
# Reduz o privilégio de execução após inicialização para o usuário e grupo abaixo - em distribuições da família Fedora e Red Hat, existe um usuário openvpn próprio. O grupo nogroup não existe.
user nobody
group nogroup
# Mantém clientes com o mesmo IP na VPN
;ifconfig-pool-persist /var/log/openvpn/ipp.txt
# Certificados e chaves necessários gerados através do easy-rsa
ca ../easy-rsa/pki/ca.crt
cert ../easy-rsa/pki/issued/nome_do_servidor.crt
key ../easy-rsa/pki/private/nome_do_servidor.key
dh ../easy-rsa/pki/dh.pem
# Lista opcional de revogação de certificados
;crl-verify ../easy-rsa/pki/crl.pem
# Chave TLS opcional para maior segurança, exigindo que pacotes recebidos tenham uma assinatura válida
;tls-auth ../easy-rsa/pki/tls-auth.key 0
Observe que as linhas do tipo
push "algum parâmetro"
são configurações que também podem ser especificadas no arquivo de configuração do cliente em vez do servidor.
Precisa-se também configurar as permissões de firewall e habilitar no kernel o encaminhamento em IPv4.
Para habilitar o encaminhamento no kernel, adicione um arquivo /etc/sysctl.d/98-ip-fwd.conf com a seguinte linha:
net.ipv4.ip_forward=1
Reinicie para que tenha efeito ou
# sysctl -w net.ipv4.ip_forward=1
No firewall, para permitir conexão de clientes:
# ufw allow 1194/udp
Caso use o servidor de VPN como um gateway ou estabeleça rota do cliente para a LAN em que o servidor está:
# ufw route allow in on tun0 out on eth0
# ufw route allow in on eth0 out on tun0
E configure o protocolo NAT adicionando este trecho no topo do arquivo /etc/ufw/before.rules
### START OF MANUAL NAT CONFIG
# NAT table rules
*nat
:POSTROUTING ACCEPT [0:0]
# Forward traffic through eth0 - Change to match you out-interface
-A POSTROUTING -s 10.8.0.0/24 -o eth0 -j MASQUERADE
# don't delete the 'COMMIT' line or these nat table rules won't
# be processed
COMMIT
### END OF MANUAL NAT CONFIG
Lembre-se de substituir a interface física e a rede pelas do seu servidor.
Alternativamente ao NAT, no caso da existência de uma LAN, você pode configurar no seu roteador uma rota para 10.8.0.0/24 pelo IP privado do seu servidor.
Agora precisamos que clientes se conectem. Pra isso, eles precisam de um arquivo de configuração do mesmo tipo que foi feito para o servidor. O easy-rsa não gera esses arquivos, então eu fiz um pequeno script pra resolver esse problema, que deixo em /etc/openvpn/easy-rsa/build-client-config.sh
Conteúdo do script:
#!/bin/bash
system=$1
client=$2
clients_dir=./clients
client_template_win=./clients/client.ovpn
client_template_lnx=./clients/client.conf
init() {
mkdir $clients_dir
cat <<'EOF' > $client_template_win
client
dev tun
proto udp4
remote servidor.exemplo.com 1194
resolv-retry infinite
nobind
persist-key
persist-tun
remote-cert-tls server
;key-direction 1
verb 3
EOF
cat <<'EOF' > $client_template_lnx
client
dev tun
proto udp4
remote servidor.exemplo.com 1194
resolv-retry infinite
nobind
persist-key
persist-tun
remote-cert-tls server
;key-direction 1
verb 3
user nobody
group nogroup
EOF
if ! [[ -f ./pki/ca.crt ]]; then
echo "CA não encontrado. Encerrando."
exit 1
else
echo "" | tee -a $client_template_lnx $client_template_win
echo "<ca>" | tee -a $client_template_lnx $client_template_win
cat pki/ca.crt | tee -a $client_template_lnx $client_template_win
echo "</ca>" | tee -a $client_template_lnx $client_template_win
fi
if [[ -f ./pki/tls-auth.key ]]; then
sed -i 's/;//g' $client_template_lnx $client_template_win
echo "" | tee -a $client_template_lnx $client_template_win
echo "<tls-auth>" | tee -a $client_template_lnx $client_template_win
cat pki/tls-auth.key | tee -a $client_template_lnx $client_template_win
echo "</tls-auth>" | tee -a $client_template_lnx $client_template_win
else
echo "tls-auth.key não encontrada, prosseguindo sem"
fi
}
if ! [[ -d $clients_dir ]]; then
init
exit
fi
if ! [[ -f ./pki/issued/$client.crt ]]; then
echo "Cliente não existe"
exit 1
fi
if [[ $system == "-l" || $system == "--linux" ]]; then
fileExt=conf
elif [[ $system == "-o" || $system == "--outro" ]]; then
fileExt=ovpn
else
echo "Sistema não especificado"
fi
targetFile=clients/$client.$fileExt
cp clients/client.$fileExt $targetFile
echo "" | tee -a $targetFile
echo "<cert>" | tee -a $targetFile
cat pki/issued/$client.crt | tee -a $targetFile
echo "</cert>" | tee -a $targetFile
echo "" | tee -a $targetFile
echo "<key>" | tee -a $targetFile
cat pki/private/$client.key | tee -a $targetFile
echo "</key>" | tee -a $targetFile
Pra inicializar, basta executar o script sem nenhum argumento
# bash build-client-config.sh
Ele vai criar uma pasta clients, com um template para Linux, client.conf, e outro para Windows, client.ovpn. Edite-os conforme necessário.
Feito isso, é possível criar o arquivo de configuração para um cliente existente com
