Comando mkdir do Linux: Criação de Diretórios

Introdução

Neste laboratório, vamos explorar o comando mkdir no Linux, uma ferramenta fundamental para criar e organizar diretórios. Vamos simular o processo de configuração de um "jardim digital" — um sistema pessoal de gestão de conhecimento — para aprender como utilizar o mkdir de forma eficaz em diversos cenários. Esta experiência prática ajudará você a entender a criação de diretórios, estruturas aninhadas e configurações de permissão no Linux, mesmo que você seja completamente iniciante na linha de comando.

Criando a Raiz do Seu Jardim Digital

Vamos começar criando o diretório raiz para o seu jardim digital.

Primeiro, abra o seu terminal. Você verá um prompt parecido com este:

labex:project/$

Isso indica que você está no diretório /home/labex/project, que é perfeito para o nosso laboratório.

Agora, vamos criar um diretório chamado digital_garden:

mkdir digital_garden

Aqui, mkdir significa "make directory" (criar diretório). Este comando cria uma nova pasta chamada digital_garden no seu local atual.

Para verificar se o diretório foi criado, usaremos o comando ls, que lista o conteúdo de um diretório:

ls

Você deverá ver digital_garden na saída. Se não visualizar, não se preocupe! Basta tentar o comando mkdir novamente.

Adicionando as Seções Principais

Em um jardim digital, é interessante organizar seus pensamentos em categorias principais. Vamos criar diretórios para diferentes tipos de conteúdo.

Criaremos três diretórios dentro do nosso digital_garden: 'notes', 'projects' e 'resources'. Você pode fazer isso com três comandos separados:

mkdir ~/project/digital_garden/notes
mkdir ~/project/digital_garden/projects
mkdir ~/project/digital_garden/resources

Aqui, ~/project/digital_garden/ é o caminho completo para o nosso jardim digital. O símbolo ~ é um atalho que representa o seu "diretório home".

Para ver a nova estrutura, use o comando ls com o caminho do seu jardim digital:

ls ~/project/digital_garden

Você deverá ver os três novos diretórios listados: notes, projects e resources.

Caso tenha curiosidade sobre para que esses diretórios poderiam servir:

• notes poderia armazenar pensamentos rápidos ou reflexões diárias.
• projects poderia conter trabalhos ou estudos de longo prazo.
• resources seria para guardar materiais de referência.

Criando Diretórios Aninhados

Muitas vezes, você precisará criar diretórios dentro de outros diretórios, gerando uma estrutura aninhada. A opção -p permite criar diretórios pai conforme necessário, o que é muito prático para estruturas profundas.

Vamos criar uma estrutura aninhada para um projeto hipotético de aplicativo web:

mkdir -p ~/project/digital_garden/projects/web_app/src/components

Este comando faz muita coisa de uma só vez:

• Cria uma pasta web_app dentro de projects.
• Dentro de web_app, cria uma pasta src.
• Por fim, dentro de src, cria uma pasta components.

A opção -p (pense em "parents" ou pais) diz ao mkdir para criar qualquer diretório pai que esteja faltando no caminho. Sem o -p, você receberia um erro se qualquer parte do caminho ainda não existisse.

Para visualizar esta nova estrutura, use o comando ls com a opção -R, que mostra o conteúdo de forma recursiva:

ls -R ~/project/digital_garden/projects/web_app

Você verá a estrutura de diretórios aninhados exibida no terminal.

Definindo Permissões de Diretório

Ao criar diretórios, você pode definir permissões específicas. Isso é útil para controlar quem pode acessar, modificar ou executar arquivos dentro daquela pasta.

Vamos criar um diretório chamado 'private' com permissões restritas:

mkdir -m 700 ~/project/digital_garden/private

Entenda o que isso faz:

• mkdir cria o diretório.
• -m 700 define as permissões.
  • 7: Leitura, escrita e execução para o proprietário.
  • 0: Sem permissões para o grupo.
  • 0: Sem permissões para outros usuários.

Em outras palavras, apenas você (o proprietário) pode acessar este diretório.

Para verificar as permissões, use:

ls -ld ~/project/digital_garden/private

A saída deve ser semelhante a esta:

drwx------ 2 labex labex 6 Aug  7 18:40 /home/labex/project/digital_garden/private

Aqui, drwx------ significa:

• d: É um diretório.
• rwx: Você (proprietário) tem permissões de leitura (read), escrita (write) e execução (execute).
• ------: Nem o seu grupo nem outros usuários possuem qualquer permissão.

Usando o Modo Detalhado (Verbose)

O modo detalhado (verbose) pode ser útil ao criar múltiplos diretórios, pois fornece um feedback sobre cada criação. Isso é especialmente valioso quando você está criando muitas pastas de uma vez e quer garantir que todas foram geradas corretamente.

Vamos criar vários diretórios usando o modo detalhado:

mkdir -v ~/project/digital_garden/resources/books ~/project/digital_garden/resources/articles ~/project/digital_garden/resources/videos

A opção -v vem de "verbose". Ela instrui o mkdir a imprimir uma mensagem para cada diretório que ele criar.

Você verá uma saída parecida com esta:

mkdir: created directory '/home/labex/project/digital_garden/resources/books'
mkdir: created directory '/home/labex/project/digital_garden/resources/articles'
mkdir: created directory '/home/labex/project/digital_garden/resources/videos'

Esse feedback é muito útil em scripts complexos ou durante a resolução de problemas.

Combinando Opções

Você pode combinar várias opções com o mkdir. Isso permite criar estruturas complexas com permissões específicas e saída detalhada, tudo em um único comando.

Vamos criar uma estrutura aninhada para um projeto de pesquisa hipotético com permissões restritas:

mkdir -pvm 750 ~/project/digital_garden/projects/research_paper/drafts ~/project/digital_garden/projects/research_paper/references

Vamos analisar os detalhes:

• -p: Cria diretórios pai conforme necessário.
• -v: Modo detalhado, imprime uma mensagem para cada diretório criado.
• -m 750: Define as permissões (proprietário: acesso total; grupo: leitura e execução; outros: sem acesso).

Este comando cria dois diretórios (drafts e references) dentro de research_paper, que por sua vez é criado dentro de projects caso ainda não exista.

Para verificar a estrutura e as permissões:

ls -lR ~/project/digital_garden/projects/research_paper

Você deverá ver os diretórios aninhados com as permissões especificadas (drwxr-x---).

Visualizando Seu Jardim Digital com o Comando tree

Agora que criamos a estrutura do nosso jardim digital, vamos usar o comando tree para visualizá-la. O comando tree exibe a estrutura de diretórios em um formato de árvore, o que é informativo e visualmente agradável.

Agora, vamos usar o tree para ver a estrutura do nosso jardim digital:

tree ~/project/digital_garden

Você verá uma saída semelhante a esta:

/home/labex/project/digital_garden
|-- notes
|-- private
|-- projects
|   |-- research_paper
|   |   |-- drafts
|   |   `-- references
|   `-- web_app
|       `-- src
|           `-- components
`-- resources
    |-- articles
    |-- books
    `-- videos

13 directories, 0 files

Essa estrutura em árvore nos dá uma visão clara do nosso jardim digital. Podemos ver todos os diretórios que criamos, incluindo as estruturas aninhadas.

Se quiser ver mais detalhes, incluindo as permissões que definimos, você pode usar a opção -p com o tree:

tree -p ~/project/digital_garden

Isso mostrará as permissões de cada diretório, assim:

[drwxrwxr-x]  /home/labex/project/digital_garden
|-- [drwxrwxr-x]  notes
|-- [drwx------]  private
|-- [drwxrwxr-x]  projects
|   |-- [drwxrwxr-x]  research_paper
|   |   |-- [drwxr-x---]  drafts
|   |   `-- [drwxr-x---]  references
|   `-- [drwxrwxr-x]  web_app
|       `-- [drwxrwxr-x]  src
|           `-- [drwxrwxr-x]  components
`-- [drwxrwxr-x]  resources
    |-- [drwxrwxr-x]  articles
    |-- [drwxrwxr-x]  books
    `-- [drwxrwxr-x]  videos

13 directories, 0 files

Esta representação visual é uma ótima maneira de verificar se criamos todos os diretórios pretendidos, com a estrutura e as permissões corretas.

Esta etapa encerra nosso laboratório de forma satisfatória, permitindo-nos contemplar toda a estrutura que construímos. O comando tree não é apenas útil para este exercício, mas é uma ferramenta valiosa para navegar e entender estruturas de diretórios em suas futuras jornadas no Linux.

Resumo

Neste laboratório, exploramos a versatilidade do comando mkdir no Linux simulando a criação de um jardim digital. Aprendemos como:

1. Criar diretórios individuais.
2. Criar múltiplos diretórios de uma só vez.
3. Criar estruturas de diretórios aninhados usando a opção -p.
4. Definir permissões específicas ao criar diretórios com a opção -m.
5. Usar o modo detalhado -v para obter feedback detalhado.

Também vimos como essas opções podem ser combinadas para operações mais complexas.

Embora não tenham sido abordados em nossos exercícios, o mkdir possui alguns parâmetros adicionais que podem ser úteis em situações específicas:

• -Z: Define o contexto de segurança SELinux de cada diretório criado para o tipo padrão.
• --context[=CTX]: Semelhante ao -Z, ou se CTX for especificado, define o contexto de segurança SELinux ou SMACK para CTX.
• --help: Exibe a mensagem de ajuda e sai.
• --version: Exibe informações da versão e sai.

Essas habilidades são fundamentais para a organização eficiente do sistema de arquivos em ambientes Linux. Lembre-se de que, embora tenhamos focado no cenário de um jardim digital, essas técnicas se aplicam a qualquer situação em que você precise criar e gerenciar estruturas de diretórios no Linux. À medida que você continuar sua jornada no Linux, descobrirá que o mkdir é uma ferramenta indispensável para organizar seus arquivos e projetos.

Recursos

• Linux Roadmap - roadmap.sh