Em ambientes corporativos, data centers e até mesmo em laboratórios domésticos avançados, a capacidade de compartilhar arquivos entre sistemas Linux e Windows de forma transparente, segura e de alto desempenho é uma habilidade fundamental para qualquer profissional de infraestrutura. É exatamente isso que você vai dominar nesta aula, combinando dois pilares do compartilhamento de arquivos em rede: NFS e Samba. O NFS (Network File System) é o protocolo nativo do universo UNIX/Linux para montar sistemas de arquivos remotos como se fossem locais, oferecendo baixa latência e integração total com permissões POSIX. Já o Samba implementa o protocolo SMB/CIFS (Server Message Block / Common Internet File System), permitindo que máquinas Linux atuem como servidores de arquivos para clientes Windows, macOS e outros Linux, com suporte a autenticação, listas de controle de acesso (ACLs) e integração com Active Directory.
Por que você precisa conhecer NFS e Samba a fundo? Imagine um cluster de servidores web que precisa acessar o mesmo diretório de assets estáticos — o NFS resolve isso com simplicidade e performance. Agora pense em uma empresa com 200 estações de trabalho Windows que precisam acessar um repositório centralizado de documentos e perfis de usuários — o Samba é a resposta. Em nossos projetos na JRT Technology Solutions, frequentemente implementamos NFS e Samba lado a lado no mesmo servidor: o NFS para comunicação interna entre servidores Linux e o Samba para servir os departamentos que utilizam Windows. Essa dualidade é tão comum que dominar ambas as tecnologias é considerado pré-requisito para cargos de administrador de sistemas pleno e sênior.
Ao final desta aula, você terá configurado do zero um servidor de arquivos funcional, capaz de exportar diretórios via NFS para clientes Linux e compartilhar pastas via Samba para máquinas Windows, com autenticação, permissões adequadas e tolerância a falhas. Todos os passos são reproduzíveis em distribuições da família Debian (Ubuntu 22.04/24.04) e da família Red Hat (Rocky Linux 9, CentOS Stream), garantindo versatilidade em qualquer infraestrutura. Você também aprenderá a testar cada configuração, interpretar logs e solucionar os problemas mais frequentes que surgem em ambientes reais de produção — aqueles que nós, da JRT Technology Solutions, enfrentamos diariamente em implantações de grande porte.
Prepare-se para uma aula densa, com mais de 4.000 palavras de conteúdo puramente prático. Abra seu terminal, tenha acesso root ou sudo em duas máquinas (uma que será o servidor e outra que será o cliente) e acompanhe com atenção. Não pule os blocos de saída esperada: eles são seu termômetro para saber se está tudo correndo como deveria. Vamos construir juntos um ambiente de compartilhamento de arquivos profissional, do zero, passo a passo.
O que você vai aprender nesta aula
- Compreender a arquitetura e o funcionamento dos protocolos NFS e SMB/CIFS
- Instalar e configurar o servidor NFS no Ubuntu/Debian e no Rocky Linux/CentOS
- Criar exports do NFS com opções avançadas de segurança e performance
- Montar compartilhamentos NFS em clientes Linux de forma temporária e permanente (fstab)
- Instalar e configurar o Samba como servidor standalone e com autenticação por usuário
- Criar e gerenciar usuários do Samba com smbpasswd e pdbedit
- Conectar clientes Windows e Linux a compartilhamentos Samba
- Ajustar firewall (firewalld e ufw) e permissões de sistema de arquivos para ambos os serviços
- Diagnosticar e corrigir os erros mais comuns em configurações de NFS e Samba
- Entender as diferenças de uso entre NFS e Samba e quando aplicar cada um
Pré-requisitos e Ambiente
Para executar todos os procedimentos desta aula, você precisará de pelo menos duas máquinas com Linux instalado — uma atuará como servidor e a outra como cliente. Recomendamos máquinas virtuais leves (1 GB de RAM, 1 vCPU) com sistemas limpos ou recém-atualizados. Nossos especialistas utilizam diariamente o VirtualBox ou Proxmox para cenários como este. Os sistemas operacionais cobertos são Ubuntu Server 22.04/24.04 LTS e Rocky Linux 9 / CentOS Stream 9. Você também precisará de um cliente Windows (virtual ou físico) para testar os compartilhamentos Samba. É imprescindível que você tenha acesso root ou privilégios sudo em ambos os sistemas Linux e que eles estejam na mesma rede local, com comunicação ICMP liberada (ping entre eles deve funcionar). Verifique também se o relógio está sincronizado via NTP ou chronyd, pois o Samba pode apresentar falhas de autenticação em caso de diferença superior a 5 minutos entre servidor e cliente. Por fim, certifique-se de que as aulas anteriores do curso foram concluídas, especialmente os tópicos de gerenciamento de usuários, permissões de arquivos e fundamentos de rede (TCP/IP, portas e firewall).
Entendendo NFS e Samba: Arquitetura e Propósito
Antes de sujar as mãos no terminal, é crucial compreender o papel de cada tecnologia no ecossistema de compartilhamento de arquivos. O NFS (Network File System) foi desenvolvido pela Sun Microsystems na década de 1980 e se tornou o padrão de fato para compartilhamento entre sistemas UNIX e Linux. Sua operação é transparente: uma vez montado, o diretório remoto se comporta exatamente como um diretório local, preservando permissões de arquivo (dono, grupo, modos), timestamps e até mesmo suporte a links simbólicos e dispositivos de bloco. O NFS opera sobre RPC (Remote Procedure Call), que por sua vez utiliza portas dinâmicas coordenadas pelo serviço rpcbind (portmapper). A versão mais comum atualmente é o NFSv4, que consolidou as operações auxiliares (mount, locking, status) em uma única porta TCP (2049), simplificando travessias de firewall e oferecendo melhorias de segurança como suporte a Kerberos e integração com ACLs estendidas.
Já o Samba é a implementação livre do protocolo SMB (Server Message Block), originalmente criado pela IBM e posteriormente adotado e estendido pela Microsoft como CIFS. O Samba permite que servidores Linux atuem como controladores de domínio, servidores de arquivos, servidores de impressão e até membros de domínios Active Directory. Para esta aula, focaremos no modo standalone (servidor independente), onde o Samba gerencia seus próprios usuários e senhas, sem dependência de um domínio central. O Samba utiliza as portas TCP 139 (NetBIOS Session, legado), 445 (SMB over TCP, moderno) e UDP 137-138 (NetBIOS Name Service, resolução de nomes). A configuração é centralizada em um único arquivo, o /etc/samba/smb.conf, que controla desde os compartilhamentos individuais até políticas de autenticação e logging.
Em nossos projetos na JRT Technology Solutions, frequentemente nos perguntam: “Qual devo usar, NFS ou Samba?” A resposta depende exclusivamente do ambiente. Se sua infraestrutura é 100% Linux/UNIX e você prioriza performance e simplicidade, o NFS é a escolha natural — ele é mais leve, não exige autenticação por usuário no modo básico e preserva permissões POSIX nativamente. Se você precisa atender estações Windows, utilizar permissões granulares baseadas em grupos do Active Directory ou oferecer suporte a clientes heterogêneos (Windows, macOS, Linux), o Samba é indispensável. Em muitos cenários reais, utilizamos ambos simultaneamente no mesmo servidor, exportando o mesmo diretório via NFS para backends e via Samba para os funcionários, cada protocolo ajustado com suas devidas camadas de segurança. Essa é a beleza do Linux: flexibilidade total.
Instalação e Configuração do Servidor NFS
Vamos começar pelo servidor NFS, que será responsável por exportar um diretório que posteriormente montaremos em um cliente Linux. O processo de instalação difere ligeiramente entre famílias de distribuições, mas o conceito é o mesmo: instalar o pacote do servidor NFS, criar o diretório a ser compartilhado, configurar o arquivo /etc/exports e ativar os serviços necessários. Acompanhe com atenção cada comando. Em sistemas Debian/Ubuntu, o pacote chama-se nfs-kernel-server, que já inclui o suporte ao NFSv4 e as ferramentas de gerenciamento. Em sistemas Red Hat/Rocky Linux, o pacote é nfs-utils, que fornece tanto o servidor quanto o cliente.
Procedimento no Ubuntu/Debian (servidor):
- Atualize o cache de pacotes e instale o servidor NFS com o comando apt update seguido de apt install nfs-kernel-server -y.
- Verifique se o serviço nfs-server está habilitado e em execução com systemctl status nfs-server.
- Crie o diretório que será exportado — usaremos /srv/nfs/compartilhado como exemplo.
- Ajuste as permissões básicas do diretório para um usuário e grupo de teste: chown nobody:nogroup /srv/nfs/compartilhado.
- Configure o arquivo /etc/exports para definir quais clientes podem acessar o diretório e com quais opções.
- Exporte as configurações com exportfs -rav e reinicie o servidor NFS para garantir.
Procedimento no Rocky Linux/CentOS (servidor):
- Instale o pacote com dnf install nfs-utils -y.
- Habilite e inicie os serviços nfs-server e rpcbind. No Rocky Linux 9, o rpcbind geralmente já está rodando, mas é prudente garantir.
- Crie o diretório /srv/nfs/compartilhado e defina o owner como nobody:nobody (no Red Hat, o grupo padrão é nobody, não nogroup).
- Edite /etc/exports com as mesmas entradas, atentando-se às políticas de SELinux que possam bloquear o acesso.
- Use exportfs -rav e reinicie o serviço.
# === SERVIDOR NFS - Ubuntu/Debian ===
# Atualizar repositórios e instalar o pacote do servidor NFS
sudo apt update
sudo apt install nfs-kernel-server -y
# Habilitar e iniciar o serviço (já é habilitado por padrão)
sudo systemctl enable nfs-server
sudo systemctl start nfs-server
# Criar o diretório base para exportação
sudo mkdir -p /srv/nfs/compartilhado
# Ajustar propriedade: nobody:nogroup é o padrão para acessos anônimos no Debian
sudo chown nobody:nogroup /srv/nfs/compartilhado
sudo chmod 755 /srv/nfs/compartilhado
● nfs-server.service - NFS server and services
Loaded: loaded (/lib/systemd/system/nfs-server.service; enabled; vendor preset: enabled)
Active: active (exited) since Mon 2026-07-06 09:15:22 -03; 12s ago
Agora, em ambos os sistemas, o coração da configuração está no arquivo /etc/exports. Este arquivo define, linha a linha, cada diretório exportado, os clientes autorizados (por IP, rede ou hostname) e as opções de montagem. A sintaxe básica é: diretorio cliente(opcoes) cliente(opcoes)…. As opções controlam comportamento de escrita, sincronização, mapeamento de usuários e muito mais. Vamos criar uma configuração robusta para nosso diretório de exemplo.
# /etc/exports — Configuração completa do servidor NFS
# Compartilha /srv/nfs/compartilhado para toda a rede 192.168.1.0/24
# Opções detalhadas:
# rw - permite leitura e escrita
# sync - escrita síncrona (mais seguro, evita corrupção de dados)
# no_subtree_check - desabilita verificação de subárvore (performance)
# no_root_squash - NÃO compacta root (use com extremo cuidado; em produção use root_squash)
# anonuid=65534 - mapeia acessos anônimos para o UID 65534 (nobody/nfsnobody)
# anongid=65534 - mapeia acessos anônimos para o GID 65534 (nogroup/nobody)
/srv/nfs/compartilhado 192.168.1.0/24(rw,sync,no_subtree_check,root_squash,anonuid=65534,anongid=65534)
# Se preferir limitar a um IP específico:
# /srv/nfs/compartilhado 192.168.1.100(rw,sync,no_subtree_check)
Após editar /etc/exports, execute exportfs -rav para recarregar a tabela de exportações sem reiniciar o serviço. A flag -r reexporta todos os diretórios; -a aplica todas as entradas do /etc/exports; -v (verbose) mostra o status de cada exportação.
# Recarregar exports e verificar o que está sendo exportado
sudo exportfs -rav
exporting 192.168.1.0/24:/srv/nfs/compartilhado
Agora, no Rocky Linux/CentOS, há um passo adicional: o firewalld e o SELinux. O NFSv4 utiliza a porta TCP 2049, mas serviços RPC auxiliares (lockd, statd, mountd) podem usar portas aleatórias, a menos que fixadas. Para simplificar, abra o serviço NFS pré-definido no firewalld e ajuste o SELinux.
# === SERVIDOR NFS - Rocky Linux 9 / CentOS Stream 9 ===
sudo dnf install nfs-utils -y
sudo systemctl enable --now nfs-server rpcbind
sudo mkdir -p /srv/nfs/compartilhado
sudo chown nobody:nobody /srv/nfs/compartilhado
sudo chmod 755 /srv/nfs/compartilhado
# Configurar firewall — adiciona os serviços NFS, rpc-bind e mountd
sudo firewall-cmd --permanent --add-service=nfs
sudo firewall-cmd --permanent --add-service=rpc-bind
sudo firewall-cmd --permanent --add-service=mountd
sudo firewall-cmd --reload
# Ajustar SELinux para permitir exportação NFS (contexto padrão: public_content_t)
sudo setsebool -P nfs_export_all_rw 1
# Ou rotular o diretório especificamente:
# sudo semanage fcontext -a -t public_content_rw_t "/srv/nfs/compartilhado(/.*)?"
# sudo restorecon -Rv /srv/nfs/compartilhado
Configuração do Cliente NFS e Montagem Permanente
Com o servidor exportando o diretório, vamos configurar o cliente Linux para montá-lo. O pacote necessário é nfs-common no Ubuntu/Debian e nfs-utils no Rocky Linux/CentOS (o mesmo pacote do servidor, que também provê as ferramentas de cliente). A montagem pode ser feita de forma temporária com o comando mount ou de forma permanente adicionando uma linha ao /etc/fstab. Para testar se o servidor está acessível e quais exports estão disponíveis, utilizamos showmount -e <IP_DO_SERVIDOR>.
# === CLIENTE NFS - Ubuntu/Debian ===
sudo apt update
sudo apt install nfs-common -y
# Verificar exports disponíveis no servidor
showmount -e 192.168.1.10
Export list for 192.168.1.10:
/srv/nfs/compartilhado 192.168.1.0/24
Crie agora um ponto de montagem local e realize a montagem temporária usando o comando mount com a opção -t nfs4 para forçar NFSv4. Após a montagem, crie um arquivo de teste e verifique as permissões.
# Criar ponto de montagem e montar o export NFS
sudo mkdir -p /mnt/nfs_cliente
sudo mount -t nfs4 192.168.1.10:/srv/nfs/compartilhado /mnt/nfs_cliente
# Verificar montagem
df -hT /mnt/nfs_cliente
# Criar arquivo de teste
echo "Teste NFS - Aula 19" | sudo tee /mnt/nfs_cliente/teste.txt
ls -la /mnt/nfs_cliente/
Filesystem Type Size Used Avail Use% Mounted on
192.168.1.10:/srv/nfs/compartilhado nfs4 50G 5.2G 45G 11% /mnt/nfs_cliente
total 12
drwxr-xr-x 2 nobody nogroup 4096 Jul 6 10:22 .
drwxr-xr-x 3 root root 4096 Jul 6 10:20 ..
-rw-r--r-- 1 nobody nogroup 21 Jul 6 10:22 teste.txt
Para que a montagem persista após reboot, adicione a entrada correspondente no /etc/fstab. Esta é uma prática padrão em servidores de produção. A sintaxe segue: servidor:/caminho ponto_montagem nfs opcoes 0 0. Opções recomendadas incluem hard (o cliente insiste na operação em caso de timeout, em vez de retornar erro), intr (permite interromper operações travadas com Ctrl+C), rsize=8192,wsize=8192 (otimização de buffer de leitura e escrita) e _netdev (aguarda a rede estar disponível antes de tentar montar).
# === /etc/fstab (cliente) ===
# Entrada completa para montagem NFS automática
192.168.1.10:/srv/nfs/compartilhado /mnt/nfs_cliente nfs4 hard,intr,rsize=8192,wsize=8192,_netdev 0 0
# Para Rocky Linux/CentOS, o tipo pode ser "nfs" ou "nfs4"
# 192.168.1.10:/srv/nfs/compartilhado /mnt/nfs_cliente nfs defaults,_netdev 0 0
Após editar o /etc/fstab, teste a montagem com mount -a, que processa todas as entradas do fstab não montadas. Se não houver saída de erro, a configuração está correta. No Rocky Linux/CentOS, pode ser necessário ajustar o SELinux no cliente também, caso utilize diretórios fora do /mnt com políticas restritivas.
Instalação e Configuração do Servidor Samba
Agora mergulharemos no Samba, o camaleão do compartilhamento de arquivos em ambientes heterogêneos. Diferente do NFS, o Samba implementa um protocolo stateful com autenticação nativa por usuário, o que o torna ideal para cenários onde diferentes pessoas precisam de diferentes níveis de acesso. Vamos configurar um servidor standalone com dois compartilhamentos: um público (somente leitura) e um privado (autenticado, leitura e escrita). A instalação do Samba é unificada em praticamente todas as distribuições modernas, com o pacote samba. No Ubuntu/Debian, instale com apt install samba -y; no Rocky Linux/CentOS, dnf install samba -y.
O arquivo de configuração principal é o /etc/samba/smb.conf. Ele é dividido em seções: a seção [global] define parâmetros que afetam o servidor como um todo (workgroup, nível de log, interfaces de rede, etc.), e cada seção com nome entre colchetes subsequente define um compartilhamento individual. Antes de editar, faça um backup do arquivo original. Em seguida, construa uma configuração limpa, explicada linha a linha, como faremos a seguir. Após alterações no smb.conf, sempre execute testparm, o verificador de sintaxe do Samba, que validará seu arquivo e exibirá os parâmetros efetivos.
# === Backup do smb.conf original ===
sudo cp /etc/samba/smb.conf /etc/samba/smb.conf.original
# Agora, edite com o conteúdo completo abaixo:
sudo nano /etc/samba/smb.conf
###############################################################################
# /etc/samba/smb.conf — SERVIDOR SAMBA STANDALONE COMPLETO
# Aula 19 - NFS e Samba
###############################################################################
[global]
# Nome do grupo de trabalho (workgroup) — deve bater com a rede Windows
workgroup = WORKGROUP
# Descrição do servidor visível na rede
server string = Servidor Samba Aula 19 - JRT Technology Solutions
# Nível de log: 2 é um bom equilíbrio entre detalhe e tamanho
log level = 2
# Arquivo de log por máquina cliente (%m = hostname)
log file = /var/log/samba/log.%m
# Tamanho máximo do log em kilobytes antes de rotacionar
max log size = 1000
# Modo de autenticação: user (padrão) exige usuário/senha local do Samba
security = user
# Backend de senhas: tdbsam (banco local TDB) — não requer LDAP ou AD
passdb backend = tdbsam
# Interfaces de rede onde o Samba escuta (ajuste para sua rede)
interfaces = 127.0.0.0/8 eth0 enp0s3
bind interfaces only = yes
# Para evitar erros de impressão, desabilitamos o compartilhamento de impressoras
load printers = no
printing = bsd
printcap name = /dev/null
disable spoolss = yes
# Ajuste para sistemas de arquivos com extended attributes (ext4, xfs)
ea support = yes
store dos attributes = yes
# Sincronizar permissões UNIX com ACLs SMB
map acl inherit = yes
# ===== Compartilhamento Público (somente leitura) =====
[publico]
comment = Compartilhamento Público - Apenas Leitura
path = /srv/samba/publico
browseable = yes
read only = yes
guest ok = yes # Permite acesso sem senha (usuário anônimo mapeado para nobody)
create mask = 0644
directory mask = 0755
# ===== Compartilhamento Privado (autenticado, leitura/escrita) =====
[privado]
comment = Compartilhamento Privado - Acesso Restrito
path = /srv/samba/privado
browseable = yes
read only = no
guest ok = no # Exige autenticação
valid users = @sambausers # Somente membros do grupo UNIX "sambausers"
create mask = 0660
directory mask = 0770
force group = sambausers # Força o grupo proprietário nos arquivos criados
Com o smb.conf pronto, crie os diretórios físicos no sistema de arquivos e defina as permissões e ownerships corretamente. Note que o compartilhamento público será acessado pelo usuário nobody e pelo grupo nogroup (Ubuntu) ou nobody (Rocky). Já o compartilhamento privado exigirá um grupo exclusivo que criaremos, chamado sambausers, e pelo menos um usuário pertencente a ele.
# Criar diretórios para os compartilhamentos
sudo mkdir -p /srv/samba/publico
sudo mkdir -p /srv/samba/privado
# Ajustar permissões do compartilhamento público
sudo chown nobody:nogroup /srv/samba/publico
sudo chmod 755 /srv/samba/publico
# Criar grupo para usuários do Samba e ajustar diretório privado
sudo groupadd sambausers
sudo chown root:sambausers /srv/samba/privado
sudo chmod 2770 /srv/samba/privado
# O bit setgid (2) faz com que novos arquivos herdem o grupo sambausers
Agora, crie um usuário no sistema Linux e o associe ao Samba. O Samba mantém sua própria base de senhas, separada do /etc/shadow. Use useradd para criar o usuário Linux, usermod -aG para adicioná-lo ao grupo sambausers, e smbpasswd -a para criar a senha do Samba. Por fim, habilite o usuário com smbpasswd -e. Verifique a lista de usuários Samba com pdbedit -L.
# Criar usuário Linux e adicionar ao grupo sambausers
sudo useradd -M -s /sbin/nologin joao_silva
sudo usermod -aG sambausers joao_silva
# Criar senha do Samba para o usuário e habilitá-lo
sudo smbpasswd -a joao_silva
# (digite a senha duas vezes)
sudo smbpasswd -e joao_silva
# Listar usuários do banco local do Samba
sudo pdbedit -L
joao_silva:1001:João Silva
Agora valide a configuração com testparm. Este comando não apenas checa erros de sintaxe, mas também exibe os valores efetivos aplicados — qualquer parâmetro omitido no seu arquivo aparecerá com o valor default. Preste atenção a warnings e erros. Se o testparm retornar “Loaded services file OK.”, você pode reiniciar o serviço.
# Verificar sintaxe e parâmetros efetivos
testparm -s
Load smb config files from /etc/samba/smb.conf
Loaded services file OK.
Weak crypto is allowed by GnuTLS (e.g. NTLM as a compatibility setting)
# Global parameters
[global]
bind interfaces only = Yes
interfaces = 127.0.0.0/8 eth0 enp0s3
log file = /var/log/samba/log.%m
max log size = 1000
passdb backend = tdbsam
printcap name = /dev/null
security = USER
server string = Servidor Samba Aula 19 - JRT Technology Solutions
workgroup = WORKGROUP
... (demais parâmetros) ...
Habilite e inicie os serviços do Samba. No Ubuntu/Debian, o serviço é smbd (servidor SMB) e, opcionalmente, nmbd (NetBIOS name server, para resolução de nomes legados). No Rocky Linux, os mesmos serviços existem, mas o firewalld deve ser configurado para liberar as portas SMB (445/tcp) e NetBIOS (139/tcp).
# === Ubuntu/Debian ===
sudo systemctl enable --now smbd nmbd
# === Rocky Linux/CentOS ===
sudo systemctl enable --now smb nmb
# Firewall Rocky Linux - liberar portas Samba
sudo firewall-cmd --permanent --add-service=samba
sudo firewall-cmd --reload
# SELinux - permitir compartilhamento de diretórios via Samba
sudo setsebool -P samba_enable_home_dirs 1
sudo setsebool -P samba_export_all_rw 1
# Ou rotular os diretórios:
# sudo semanage fcontext -a -t samba_share_t "/srv/samba(/.*)?"
# sudo restorecon -Rv /srv/samba
Conectando Clientes ao Samba
Agora que o servidor Samba está em execução, é hora de testar os acessos a partir de duas perspectivas: um cliente Linux usando smbclient e mount.cifs, e um cliente Windows utilizando o Explorador de Arquivos. Para o Linux, instale o pacote smbclient e cifs-utils no Ubuntu/Debian, ou samba-client e cifs-utils no Rocky Linux. O smbclient é uma ferramenta interativa semelhante a um cliente FTP para acessar compartilhamentos SMB. Já o mount.cifs permite montar um compartilhamento Samba em um ponto de montagem do sistema de arquivos, similar ao NFS.
# === CLIENTE SAMBA - Ubuntu/Debian ===
sudo apt update
sudo apt install smbclient cifs-utils -y
# Listar compartilhamentos disponíveis no servidor (192.168.1.10)
smbclient -L //192.168.1.10 -U joao_silva
Password for [WORKGROUP\joao_silva]:
Sharename Type Comment
--------- ---- -------
publico Disk Compartilhamento Público - Apenas Leitura
privado Disk Compartilhamento Privado - Acesso Restrito
IPC$ IPC IPC Service (Servidor Samba Aula 19 - JRT Technology Solutions)
Acesse o compartilhamento público (sem senha) e o privado (com autenticação) usando smbclient. No modo interativo, comandos como ls, get e put permitem navegar e transferir arquivos.
# Acessar compartilhamento público (anônimo)
smbclient //192.168.1.10/publico -N
# Acessar compartilhamento privado (autenticado)
smbclient //192.168.1.10/privado -U joao_silva
Para uma integração mais profunda, monte o compartilhamento Samba em um diretório local com mount.cifs. As opções username=, password=, uid=, gid= e file_mode= / dir_mode= oferecem controle granular sobre a montagem. Para não expor senhas em scripts, utilize um arquivo de credenciais (por exemplo, /root/.smbcredentials) com permissão 600.
# Criar arquivo de credenciais (somente root pode ler)
sudo bash -c 'echo -e "username=joao_silva\npassword=SenhaSegura123" > /root/.smbcredentials'
sudo chmod 600 /root/.smbcredentials
# Montar o compartilhamento privado
sudo mkdir -p /mnt/samba_privado
sudo mount -t cifs //192.168.1.10/privado /mnt/samba_privado \
-o credentials=/root/.smbcredentials,uid=1000,gid=1001,file_mode=0660,dir_mode=0770
# Verificar montagem
df -hT /mnt/samba_privado
Filesystem Type Size Used Avail Use% Mounted on
//192.168.1.10/privado cifs 50G 5.2G 45G 11% /mnt/samba_privado
No Windows, o procedimento é direto: abra o Explorador de Arquivos (Tecla Windows + E), na barra de endereços digite \\192.168.1.10\publico ou \\192.168.1.10\privado e pressione Enter. Para o compartilhamento privado, uma janela de autenticação solicitará usuário e senha — utilize as credenciais Samba configuradas (joao_silva e a senha definida). Você poderá criar, editar e excluir arquivos dentro do diretório montado, desde que as permissões do sistema de arquivos e a configuração do share permitam.
Verificando a Instalação / Testando a Configuração
Esta é a seção de validação, onde você comprova que cada componente está operando conforme esperado. Vamos executar uma bateria de comandos de diagnóstico e verificar as saídas. Faça todos os testes na ordem apresentada; se algum falhar, consulte a seção de erros comuns logo a seguir. Começamos pelo NFS.
# === TESTES NFS - Servidor ===
# Verificar status dos serviços NFS e rpcbind
sudo systemctl status nfs-server rpcbind --no-pager -l
# Checar quais diretórios estão sendo exportados ativamente
sudo exportfs -v
# Verificar portas RPC em escuta
rpcinfo -p | grep nfs
# Saída esperada de "rpcinfo -p | grep nfs"
100003 3 tcp 2049 nfs
100003 4 tcp 2049 nfs
100227 3 tcp 2049 nfs_acl
# === TESTES NFS - Cliente ===
# Listar exports disponíveis
showmount -e 192.168.1.10
# Verificar montagens ativas do tipo nfs
mount | grep nfs4
# Testar escrita e leitura
echo "Teste de validacao NFS" > /mnt/nfs_cliente/validacao.txt
cat /mnt/nfs_cliente/validacao.txt
Export list for 192.168.1.10:
/srv/nfs/compartilhado 192.168.1.0/24
Teste de validacao NFS
Agora os testes do Samba, tanto no servidor quanto no cliente:
# === TESTES SAMBA - Servidor ===
# Verificar estado dos serviços
sudo systemctl status smbd nmbd --no-pager -l
# Validar sintaxe do smb.conf e exibir parâmetros efetivos
testparm -s
# Listar usuários Samba cadastrados
sudo pdbedit -L -v
# Verificar portas em escuta (445 e 139)
sudo ss -tlnp | grep -E '445|139'
LISTEN 0 50 0.0.0.0:445 0.0.0.0:* users:(("smbd",pid=1234,fd=40))
LISTEN 0 50 0.0.0.0:139 0.0.0.0:* users:(("smbd",pid=1234,fd=39))
# === TESTES SAMBA - Cliente Linux ===
# Listar shares
smbclient -L //192.168.1.10 -U joao_silva
# Conectar ao share público e listar conteúdo
smbclient //192.168.1.10/publico -N -c 'ls'
# Conectar ao share privado e criar arquivo
smbclient //192.168.1.10/privado -U joao_silva -c 'put /etc/hostname hostname.txt'
# Verificar montagem CIFS
ls -la /mnt/samba_privado
# smbclient -c 'put' deve retornar algo como:
putting file /etc/hostname as \hostname.txt (0,1 kb/s) (average 0,3 kb/s)
No Windows, valide acessando \\192.168.1.10\publico e \\192.168.1.10\privado via Explorador de Arquivos. Crie um arquivo de texto no bloco de notas e salve diretamente no compartilhamento privado; depois verifique no servidor Linux se o arquivo aparece em /srv/samba/privado. Essa integração bidirecional é a prova definitiva de que o Samba está funcionando corretamente.
Erros Comuns e Como Resolver
Em nossa experiência na JRT Technology Solutions, cerca de 80% dos problemas com NFS e Samba recaem sobre quatro categorias: permissões de sistema de arquivos, firewall/SELinux bloqueando tráfego, sintaxe incorreta nos arquivos de configuração e incompatibilidade de versões de protocolo. Abaixo, listamos os mais frequentes, seus sintomas, causas e as soluções exatas que nossos especialistas aplicam em campo.
- Erro: “Permission denied” ao escrever em compartilhamento NFS. Sintoma: o cliente monta o export com sucesso, mas ao tentar criar arquivos, recebe “Permission denied”, mesmo com a opção rw no /etc/exports. Causa: o UID/GID do usuário no cliente não corresponde ao proprietário do diretório no servidor, e a opção root_squash (padrão) está ativa, mapeando acessos de root para nobody. Solução: verifique os UIDs com id usuario em ambos os sistemas. Ajuste o diretório exportado com chown UID:GID no servidor. Se necessário, use a opção no_root_squash (apenas em ambientes controlados) ou all_squash combinado com anonuid/anongid para uniformizar os acessos. Recarregue com exportfs -rav.
- Erro: Cliente NFS fica travado ao perder conectividade (“hard mount” congelado). Sintoma: processos no cliente ficam em estado D (uninterruptible sleep) quando o servidor NFS cai, travando até shells que tentam listar o diretório montado. Causa: a opção padrão de montagem é hard, que insiste indefinidamente. Solução: utilize a opção soft no mount ou no fstab para que o cliente retorne erro após timeout, permitindo que aplicações tratem a falha. Exemplo: mount -o soft,timeo=30 …. Em sistemas críticos, considere hard,intr para permitir interrupção via sinal (Ctrl+C).
- Erro: “testparm” acusa “rlimit_max: increasing rlimit_max (8192) to minimum Windows limit (16384)” ou falha ao carregar. Sintoma: o Samba não sobe ou apresenta lentidão extrema, e logs mostram falha de alocação de recursos. Causa: limite de arquivos abertos (ulimit -n) muito baixo para o Samba. Solução: edite /etc/security/limits.conf e adicione * – nofile 16384. Reinicie a sessão ou o serviço. Verifique também se o parâmetro max open files no smb.conf está definido para um valor razoável (ex: 16384).
- Erro: “NT_STATUS_BAD_NETWORK_NAME” ou “Unable to connect to IPC$ share”. Sintoma: ao listar compartilhamentos com smbclient -L, o servidor responde, mas a listagem falha com erro de nome de rede. Causa: firewall bloqueando a porta TCP 445 ou o serviço nmbd não está em execução para resolução NetBIOS. Solução: verifique com ss -tlnp | grep 445 se o smbd está escutando em todas as interfaces. Teste conectividade com telnet 192.168.1.10 445. Certifique-se de que o firewalld/ufw liberou a porta. No UFW: ufw allow samba. Verifique systemctl status nmbd e habilite se necessário.
- Erro: “mount.nfs: access denied by server while mounting” no cliente, mas showmount funciona. Sintoma: showmount -e mostra os exports corretos, mas a montagem é negada. Causa: o cliente está tentando montar usando uma versão NFS diferente da suportada ou a opção no_subtree_check combinada com diretório que é subdiretório de outro export causa conflito. Solução: force a versão no cliente com -o nfsvers=4 ou -t nfs4. Verifique os logs do servidor com journalctl -u nfs-server -f durante a tentativa de montagem — mensagens “refused mount request from CLIENT_IP for /caminho …” indicam mismatch de opções ou cliente não autorizado na rede listada no /etc/exports.
- Erro: SELinux bloqueia acesso Samba mesmo com permissões corretas. Sintoma: o serviço está ativo, firewall liberado, mas clientes recebem “Access Denied”. Causa: contexto SELinux do diretório compartilhado não permite acesso a smbd_t. Solução: execute sudo setsebool -P samba_export_all_rw 1 ou rotule o diretório com semanage fcontext -a -t samba_share_t “/caminho(/.*)?” seguido de restorecon -Rv /caminho. Verifique violações no SELinux com ausearch -m avc -ts recent.
Boas Práticas e Dicas Avançadas
Configurar NFS e Samba que “funcionam” é o primeiro passo; configurá-los de forma profissional e sustentável exige algumas camadas adicionais de cuidado que acumulamos em centenas de implantações. Primeiramente, sempre fixe as versões de protocolo. No NFS, utilize explicitamente nfsvers=4.2
Quer aprender na prática com especialistas?
A JRT Technology Solutions oferece treinamentos e implementação de Linux para equipes corporativas.