Como Criar uma Nova Pasta no Ubuntu: Guia Completo de Gerenciamento de Diretórios

Criar uma nova pasta no Ubuntu é feito principalmente com o comando mkdir no terminal. A sintaxe básica é mkdir folder_name, que cria instantaneamente um diretório na sua localização de trabalho atual. Para estruturas aninhadas, mkdir -p parent/child/grandchild cria todo o caminho numa única operação, mesmo que os diretórios intermediários ainda não existam.

Este guia vai muito além do básico. Abrange todos os métodos práticos para criar diretórios no Ubuntu — desde a criação simples de uma única pasta até estruturas recursivas, provisionamento com controlo de permissões e padrões de scripting prontos para automação utilizados em ambientes reais de servidores de produção.

Por que a Estrutura de Diretórios Adequada é Importante num Servidor Linux

Em qualquer servidor Ubuntu, o sistema de ficheiros é a espinha dorsal de cada operação. Diretórios mal organizados criam problemas em cascata: caminhos de aplicações quebrados, hierarquias de permissões mal configuradas, tarefas de backup falhadas e vulnerabilidades de segurança causadas por diretórios com permissão de escrita para todos colocados em locais sensíveis.

Uma abordagem disciplinada à gestão de diretórios afeta diretamente:

• Herança de permissões — os diretórios filhos herdam as permissões dos diretórios pai, a menos que sejam explicitamente substituídas, tornando as decisões iniciais de estrutura críticas
• Âmbito de backup — ferramentas de backup como rsync e tar operam em árvores de diretórios, pelo que o agrupamento lógico reduz a complexidade do backup
• Configuração de serviços — servidores web (Apache, Nginx), bases de dados e runtimes de aplicações dependem de caminhos de diretórios previsíveis e bem definidos
• Auditoria e conformidade — caminhos estruturados tornam a correlação de logs e a análise forense significativamente mais rápidas

Se estiver a gerir um ambiente de VPS Hosting ou um Servidor Dedicado, estabelecer uma convenção de diretórios consistente desde o primeiro dia evita dívida técnica que se acumula rapidamente à medida que o sistema cresce.

Pré-requisitos

Antes de executar qualquer um dos comandos abaixo, confirme o seguinte:

• Tem acesso a um terminal (local ou via SSH)
• A sua conta de utilizador tem permissão de escrita no local de destino
• Para diretórios ao nível do sistema (por exemplo, em /etc/ ou /var/), tem privilégios sudo
• Versão do Ubuntu: estes comandos aplicam-se universalmente ao Ubuntu 18.04, 20.04, 22.04 e 24.04 LTS

Para verificar o seu diretório de trabalho atual a qualquer momento, execute:

pwd

Método 1: Criação Básica de Diretórios com mkdir

O comando mkdir (make directory) é o utilitário POSIX padrão para criar diretórios. Está disponível em todas as distribuições Linux sem instalação.

Sintaxe:

mkdir directory_name

Exemplo:

mkdir project_files

Isto cria um diretório chamado project_files na sua localização atual. O comando não produz nenhuma saída em caso de sucesso — este é o comportamento Unix padrão. Para confirmar a criação:

ls -la

Convenções de nomenclatura a seguir em produção:

• Use letras minúsculas e underscores ou hífens: web_assets, backup-2024
• Evite espaços nos nomes de diretórios — requerem escape (mkdir "my folder" ou mkdir my folder) e quebram muitos scripts de shell
• Evite caracteres especiais: &, *, ?, !, | têm significados específicos do shell e causam comportamento imprevisível

Método 2: Criar um Diretório num Caminho Absoluto Específico

Em vez de navegar primeiro para um local de destino, pode passar o caminho absoluto completo diretamente para mkdir. Esta é a abordagem preferida em scripts e provisionamento automatizado.

Sintaxe:

mkdir /full/path/to/new_directory

Exemplo:

mkdir /var/www/html/myapp

Restrição importante: Este comando falhará se algum diretório intermediário no caminho ainda não existir. Por exemplo, se /var/www/html/ não existir, o comando acima retorna:

mkdir: cannot create directory '/var/www/html/myapp': No such file or directory

A solução é o sinalizador -p, abordado no Método 3.

Usar caminhos relativos é igualmente válido e frequentemente mais legível em sessões interativas:

mkdir ../sibling_directory
mkdir ./subdirectory

Método 3: Criar Diretórios Aninhados Recursivamente com -p

O sinalizador -p (parents) é uma das opções operacionalmente mais importantes em mkdir. Instrui o comando a criar todos os diretórios intermediários em falta no caminho especificado, e suprime o erro que normalmente ocorreria se o diretório de destino já existisse.

Sintaxe:

mkdir -p parent_directory/child_directory/grandchild_directory

Exemplo:

mkdir -p /var/www/html/myapp/logs/archive

Se /var/www/html/myapp/ não existir, este único comando cria toda a cadeia: myapp, depois logs dentro dele, depois archive dentro desse.

Caso de uso crítico em produção — raízes de documentos de servidores web:

mkdir -p /var/www/vhosts/example.com/{public_html,logs,ssl,tmp}

Esta sintaxe de expansão de chavetas (abordada em detalhe no Método 6) combinada com -p é um padrão standard para provisionar novos ambientes de hosts virtuais num único comando.

O sinalizador -p também evita erros em scripts idempotentes. Se executar o mesmo comando mkdir -p duas vezes, a segunda execução não faz nada e termina corretamente com o código 0. Sem -p, a segunda execução retornaria um erro, quebrando qualquer script que use set -e (sair em caso de erro).

Método 4: Criar Múltiplos Diretórios Simultaneamente

mkdir aceita múltiplos argumentos, criando todos os diretórios especificados numa única invocação.

Sintaxe:

mkdir dir1 dir2 dir3

Exemplo:

mkdir assets uploads cache sessions

Isto cria quatro diretórios separados na localização atual. Todos os diretórios são criados ao mesmo nível — esta não é uma estrutura aninhada.

Combinando com caminhos absolutos:

mkdir /srv/app/modules /srv/app/config /srv/app/data

Combinando com -p para múltiplos caminhos aninhados:

mkdir -p /srv/project/frontend/src /srv/project/backend/src /srv/project/docs

Isto é particularmente útil ao estruturar um novo diretório de aplicação antes da implementação.

Método 5: Criar Diretórios com Permissões Específicas Usando -m

Por padrão, mkdir aplica permissões com base no valor de umask do sistema. Na maioria dos sistemas Ubuntu, o umask padrão é 0022, o que significa que os novos diretórios recebem permissões de 755 (proprietário: leitura/escrita/execução; grupo: leitura/execução; outros: leitura/execução).

Em muitos cenários de servidor, as permissões padrão são demasiado permissivas ou demasiado restritivas. O sinalizador -m permite definir permissões exatas no momento da criação usando notação octal.

Sintaxe:

mkdir -m octal_mode directory_name

Padrões de permissão comuns:

Exemplo — criar um diretório seguro para chaves SSH:

mkdir -m 700 ~/.ssh

Exemplo — criar uma raiz web com permissões corretas:

mkdir -m 755 /var/www/html/newsite

Combinando -m e -p:

mkdir -p -m 750 /srv/app/config/secrets

Note que ao usar -p, o modo é aplicado apenas ao diretório final no caminho, não a quaisquer diretórios intermediários que sejam criados. Os diretórios intermediários recebem as permissões padrão baseadas no umask. Se precisar de controlo preciso sobre todos os níveis, crie cada nível individualmente com sinalizadores -m explícitos, ou use chmod posteriormente.

Método 6: Expansão de Chavetas para Árvores de Diretórios Complexas

A expansão de chavetas é uma funcionalidade do shell Bash — não uma opção do mkdir — que gera múltiplos argumentos a partir de um único padrão. Combinada com mkdir -p, é a forma mais eficiente de criar hierarquias de diretórios complexas.

Expansão básica de chavetas:

mkdir -p project/{src,tests,docs,build}

Isto expande para:

mkdir -p project/src project/tests project/docs project/build

Expansão de chavetas em múltiplos níveis:

mkdir -p app/{frontend/{components,pages,styles},backend/{controllers,models,routes},shared/utils}

Isto cria a seguinte estrutura:

app/
├── frontend/
│   ├── components/
│   ├── pages/
│   └── styles/
├── backend/
│   ├── controllers/
│   ├── models/
│   └── routes/
└── shared/
    └── utils/

Este padrão é prática standard ao inicializar novos repositórios de aplicações ou provisionar diretórios de aplicações num VPS com cPanel novo ou servidor bare-metal.

Método 7: Criar Diretórios através da GUI do Ubuntu (Aplicação Ficheiros)

Para instalações de desktop Ubuntu ou sessões de ambiente de trabalho remoto, a aplicação GNOME Ficheiros (Nautilus) fornece um método gráfico.

Passos:

1. Abra a aplicação Ficheiros a partir do menu Atividades ou da barra de tarefas
2. Navegue para o diretório pai onde pretende criar a nova pasta
3. Clique com o botão direito numa área vazia dentro do diretório
4. Selecione Nova Pasta no menu de contexto
5. Digite o nome de pasta pretendido e pressione Enter

Atalho de teclado: No Nautilus, Ctrl+Shift+N cria uma nova pasta instantaneamente sem usar o menu do botão direito.

Limitações da abordagem GUI:

• Não é possível definir permissões personalizadas durante a criação — requer uma ação de seguimento no terminal ou nas propriedades do ficheiro
• Não é possível criar estruturas aninhadas recursivas numa única operação
• Não está disponível em ambientes de servidor sem interface gráfica (a grande maioria dos servidores Ubuntu de produção funciona sem ambiente de desktop)

Para qualquer trabalho sério de administração de servidores, os métodos de linha de comandos são sempre preferidos.

Método 8: Scripting da Criação de Diretórios para Automação

Na administração real de servidores, os diretórios raramente são criados manualmente um de cada vez. Scripts de provisionamento, pipelines de implementação e ferramentas de gestão de configuração dependem todos da criação automatizada de diretórios.

Exemplo básico de script de shell:

#!/bin/bash
set -e

BASE_DIR="/var/www/vhosts"
DOMAIN="example.com"

directories=(
    "$BASE_DIR/$DOMAIN/public_html"
    "$BASE_DIR/$DOMAIN/logs"
    "$BASE_DIR/$DOMAIN/ssl"
    "$BASE_DIR/$DOMAIN/tmp"
    "$BASE_DIR/$DOMAIN/backup"
)

for dir in "${directories[@]}"; do
    mkdir -p "$dir"
    echo "Created: $dir"
done

# Set ownership to web server user
chown -R www-data:www-data "$BASE_DIR/$DOMAIN"
chmod -R 755 "$BASE_DIR/$DOMAIN"

echo "Directory structure for $DOMAIN provisioned successfully."

Práticas essenciais de scripting:

• Use sempre set -e para abortar em caso de qualquer erro
• Coloque todas as variáveis entre aspas ("$dir") para tratar caminhos com espaços de forma segura
• Combine mkdir -p com chown e chmod no mesmo script para garantir que as permissões estão corretas imediatamente após a criação
• Use arrays para listas de diretórios para manter os scripts legíveis e fáceis de manter

Esta abordagem é essencial ao gerir múltiplos hosts virtuais, implementar aplicações em diferentes ambientes, ou automatizar a configuração de servidores com ferramentas como Ansible ou scripts de provisionamento baseados em Bash.

Comparação: Opções do mkdir e os Seus Casos de Uso

Erros Comuns e Como Corrigi-los

Erro: Permission denied

mkdir: cannot create directory '/etc/myapp': Permission denied

Causa: Está a tentar escrever num diretório pertencente ao sistema sem privilégios elevados.

Correção: Adicione sudo antes do comando:

sudo mkdir /etc/myapp

Erro: No such file or directory

mkdir: cannot create directory '/srv/app/config': No such file or directory

Causa: Um ou mais diretórios intermediários no caminho não existem.

Correção: Use o sinalizador -p:

mkdir -p /srv/app/config

Erro: File exists

mkdir: cannot create directory 'mydir': File exists

Causa: Já existe um diretório ou ficheiro com esse nome.

Correção: Use -p para suprimir este erro quando o caminho existente é um diretório, ou escolha um nome diferente.

Falha silenciosa em scripts: Se mkdir falhar e o seu script não usar set -e ou verificar códigos de saída, as operações subsequentes podem prosseguir num caminho inexistente, causando falhas imprevisíveis. Valide sempre a criação de diretórios críticos:

mkdir -p /srv/app/data || { echo "Failed to create data directory"; exit 1; }

Considerações de Segurança para a Criação de Diretórios

As permissões de diretórios são uma primeira linha de defesa na segurança do servidor. Várias vulnerabilidades de alto impacto resultam diretamente de permissões incorretas de diretórios:

• Diretórios com permissão de escrita para todos (777) permitem que qualquer utilizador no sistema escreva, modifique ou elimine ficheiros — um risco crítico em hosting partilhado ou servidores multiutilizador
• Propriedade incorreta em diretórios voltados para a web pode permitir que exploits de aplicações web escrevam ficheiros maliciosos fora da raiz de documentos pretendida
• Sticky bit (chmod +t) em diretórios partilhados (como /tmp) impede que os utilizadores eliminem ficheiros pertencentes a outros — defina sempre isto em diretórios partilhados com permissão de escrita
• Bit SetGID em diretórios garante que os novos ficheiros herdam o grupo do diretório em vez do grupo primário do utilizador que os cria — útil para diretórios de projetos colaborativos

Exemplo — diretório de projeto partilhado seguro:

mkdir -p /srv/shared/project
chown root:developers /srv/shared/project
chmod 2775 /srv/shared/project  # SetGID + rwxrwxr-x

Ao hospedar aplicações web, domínios com SSL ou serviços de email, as permissões adequadas de diretórios são inseparáveis da postura de segurança da sua configuração de Certificados SSL e da sua configuração de Email Hosting.

Verificar a Criação de Diretórios

Após criar diretórios, verifique sempre o resultado antes de prosseguir com operações dependentes.

Listar com permissões detalhadas:

ls -la /path/to/parent/

Verificar se um diretório específico existe (útil em scripts):

[ -d /srv/app/config ] && echo "Directory exists" || echo "Directory missing"

Ver a estrutura completa em árvore (requer o pacote tree):

sudo apt install tree -y
tree /srv/app/

Verificar o uso de inodes — em servidores com muitos ficheiros pequenos, o esgotamento de inodes pode impedir a criação de diretórios mesmo quando há espaço em disco disponível:

df -i /srv/

Se o uso de inodes estiver próximo de 100%, não é possível criar novos diretórios ou ficheiros independentemente do espaço em disco disponível. Este é um problema comum de produção em servidores que hospedam grandes quantidades de ficheiros pequenos, como servidores de email ou diretórios de sessões PHP.

Matriz de Decisão Prática: Qual Método Usar

Principais Conclusões Técnicas

• mkdir -p é o padrão mais seguro para qualquer criação de diretórios em scripts ou automatizada — é idempotente e trata caminhos intermediários em falta
• Nunca use permissões 777 em diretórios de produção; prefira 755 para caminhos públicos e 750 ou 700 para dados sensíveis
• O sinalizador -m em mkdir define permissões apenas no diretório final quando usado com -p — use chmod -R ou chamadas mkdir por nível para controlo total
• A expansão de chavetas é uma funcionalidade do Bash, não do mkdir — não funcionará em scripts /bin/sh a menos que o shell seja Bash
• Verifique sempre a disponibilidade de inodes (df -i) em sistemas de ficheiros de alta densidade antes da criação em massa de diretórios
• Combine a criação de diretórios com a atribuição imediata de chown em scripts de provisionamento para evitar uma janela em que os diretórios existem com propriedade incorreta
• Em ambientes de Painéis de Controlo VPS, os utilizadores de servidores web (tipicamente www-data ou nginx) devem ter permissão de execução em todos os diretórios no caminho da raiz de documentos — não apenas no diretório final

FAQ

Qual é a diferença entre mkdir folder e mkdir -p folder?

mkdir folder cria um único diretório e falha se qualquer parte do caminho não existir ou se o diretório já existir. mkdir -p folder cria todos os diretórios intermediários em falta e termina silenciosamente sem erro se o destino já existir, tornando-o seguro para scripts e execução repetida.

O mkdir pode criar um diretório com espaços no nome?

Sim. Coloque o nome entre aspas: mkdir "my project folder" ou faça escape dos espaços: mkdir my project folder. No entanto, espaços nos nomes de diretórios são fortemente desaconselhados em servidores porque requerem escape em cada comando subsequente e quebram muitos scripts de shell e configurações de aplicações.

Por que o mkdir falha com “Permission denied” mesmo com sudo?

Isto ocorre tipicamente quando o sistema de ficheiros de destino está montado como somente leitura, quando as políticas SELinux ou AppArmor restringem escritas nesse caminho, ou quando o caminho está num sistema de ficheiros de rede com restrições do lado do servidor. Verifique as opções de montagem com mount | grep /target/path e reveja os logs do AppArmor com sudo aa-status.

Como criar um diretório e definir imediatamente o seu proprietário e grupo?

mkdir não define a propriedade — use chown imediatamente depois: mkdir -p /srv/app && chown www-data:www-data /srv/app. Num único pipeline: install -d -m 755 -o www-data -g www-data /srv/app — o comando install cria diretórios com proprietário, grupo e modo num único passo.

O que acontece às permissões ao usar mkdir -p com múltiplos novos níveis?

Apenas o diretório final (mais profundo) recebe o modo especificado por -m. Todos os diretórios intermediários recém-criados recebem permissões derivadas do umask atual. Se forem necessárias permissões consistentes em todos os níveis, crie cada nível individualmente com sinalizadores -m explícitos ou aplique chmod -R após a criação do caminho completo.