Prompt Partição Linux

Docker Inteligência Artificial No Comments

Prompt

Estou criando uma VM na Azure, com Linux. Estou com extrema dúvida com relação à configuração das partições do disco. Estou usando um disco de 200GB e pretendo rodar uma aplicação Python com Docker. Defina a melhor configuração das partições (/, /home, /boot, /tmp, /usr, /var, etc).

ChatGPT (Adapta)

Aqui vai um guia completo e prático para particionar um Linux na Azure (disco de 200 GB) visando rodar uma aplicação Python em Docker, com foco em segurança, facilidade de manutenção e espaço adequado para imagens/volumes.

Resumo rápido (recomendação direta)

  • Sistema de arquivos: ext4 (simples e sem pegadinhas). Se optar por XFS, garanta ftype=1 no /var/lib/docker.
  • Layout recomendado (com LVM):
    • EFI (Gen2): /boot/efi — 550 MB (FAT32)
    • /boot — 1 GB (ext4)
    • swap — 8–16 GB (em geral 1x a RAM até 16 GB; sem hibernação)
    • / — 40 GB (ext4)
    • /var/lib/docker — 120 GB (ext4)
    • /var/log — 8 GB (ext4)
    • /home — 10 GB (ext4)
    • /tmp — tmpfs 2–4 GB (não em disco; memória)
    • Reserva livre no VG — ~5–10 GB para crescimento futuro
  • Opções de montagem (segurança e performance):
    • /: defaults,noatime
    • /boot: nodev
    • /tmp: tmpfs,size=4G,noexec,nodev,nosuid
    • /var/log: nodev,nosuid,noexec
    • /var/lib/docker: defaults,noatime (não usar noexec aqui)
  • Docker: usar overlay2; configurar rotação de logs (max-size=100m, max-file=5).
  • Azure: use o disco temporário (normalmente /dev/sdb, montado em /mnt ou /mnt/resource) só para swap temporária e caches. Não coloque dados persistentes nem /var/lib/docker ali.

Por que esse layout?

  • Docker consome pesado em /var/lib/docker (imagens, camadas, volumes). Dedicar um LV/partição ajuda a evitar que o host “morra” por falta de espaço no /.
  • /var/log separado evita que logs tomem a máquina. Com noexec/nodev/nosuid, reduz risco.
  • /tmp em tmpfs é rápido e não ocupa disco. Para cargas muito grandes em /tmp, ajuste o size ou redirecione a aplicação.
  • LVM permite crescer/shrink com mais segurança (especialmente crescer). Deixe um “colchão” livre no VG.
  • Manter /usr junto do / (sem separar) simplifica boot e evita problemas (muitos sistemas já assumem /usr disponível cedo).

Tamanhos sugeridos (200 GB)

  • EFI (se Gen2): 550 MB
  • /boot: 1 GB
  • swap: 8–16 GB (depende da RAM; sem hibernação)
  • / (root): 40 GB
  • /var/lib/docker: 120 GB
  • /var/log: 8 GB
  • /home: 10 GB
  • Sobra no VG: ~5–10 GB (ajuste conforme necessidade) Observação: os números são aproximados. Se você prevê muitas imagens/volumes, aumente /var/lib/docker e reduza a sobra ou /home.

Alternativas de layout (escolha conforme seu cenário)

  1. Simples e robusto (recomendado para a maioria)
  • LVM: sim
  • Partições/LVs: /boot, swap, /, /var/lib/docker, /var/log, /home, /tmp em tmpfs
  • Vantagens: segurança contra “disco cheio”, fácil de ajustar, bom para Docker
  • Desvantagens: um pouco mais de passos na configuração inicial
  1. Minimalista (tudo em / + swap) — só se você quer simplicidade extrema
  • /boot (1 GB), swap, / (todo o resto)
  • /tmp em tmpfs
  • Vantagens: simples
  • Desvantagens: se /var/lib/docker crescer demais, derruba o host; precisa de quotas ou monitoramento rigoroso
  1. Melhor prática Azure (ideal): OS + disco(s) de dados separados
  • OS disk menor (por exemplo 64–128 GB) e 1 data disk para /var/lib/docker (200 GB, Premium SSD, cache None)
  • Vantagens: isolamento, performance e backup melhores
  • Desvantagens: exige anexar outro disco (mas na Azure é fácil e recomendado)

Sistema de arquivos

  • ext4: padrão, estável e simples. Bom para tudo, inclusive Docker.
  • xfs: excelente performance com arquivos grandes; se usar em /var/lib/docker, formate com ftype=1 (obrigatório para overlay2).
  • Btrfs/ZFS: possíveis, mas aumentam a complexidade. Para produção simples em Azure, prefira ext4/xfs.

Notas específicas da Azure (importante)

  • Disco temporário (local/efêmero): aparece como /dev/sdb e monta em /mnt ou /mnt/resource (em Ubuntu). Use para swap temporária, cache de build, pip cache. Dados podem sumir a qualquer momento (reinício, realocação).
  • TRIM/Discard: mantenha o fstrim.timer ativado (padrão nas distros modernas) para recuperar espaço em Managed Disks.
  • Tipo de disco: para Docker em produção, prefira Premium SSD ou Premium SSD v2. Defina o Host Cache do data disk de Docker como None para cargas de escrita intensas.
  • Monitoramento: use métricas de disco no Azure Monitor, crie alertas para uso > 80% em /var/lib/docker.

Exemplo de /etc/fstab Ajuste UUIDs conforme seus sistemas. Exemplo de opções sólidas:

UUID=xxxx-efi /boot/efi vfat umask=0077 0 1 UUID=xxxx-boot /boot ext4 nodev,nofail 0 2 UUID=xxxx-root / ext4 defaults,noatime,errors=remount-ro 0 1 UUID=xxxx-log /var/log ext4 nodev,nosuid,noexec,noatime 0 2 UUID=xxxx-dkr /var/lib/docker ext4 defaults,noatime 0 2 UUID=xxxx-home /home ext4 nodev,nosuid,noatime 0 2 tmpfs /tmp tmpfs defaults,size=4G,noexec,nodev,nosuid 0 0

Swap: prefira swapfile no disco temporário da Azure (se disponível) ou um LV de swap no OS disk. Exemplo de tmp-based swap:

  • Crie em /mnt (disco efêmero): sudo fallocate -l 8G /mnt/swapfile && sudo chmod 600 /mnt/swapfile && sudo mkswap /mnt/swapfile && echo “/mnt/swapfile none swap sw 0 0” | sudo tee -a /etc/fstab
  • Lembre-se: swap no disco efêmero some em eventos de realocação. Mas é aceitável para swap.

Configuração do Docker

  • Driver de storage: overlay2 (padrão nas distros recentes)
  • Mover a raiz do Docker para a partição dedicada:
    • Parar Docker: sudo systemctl stop docker
    • Garantir /var/lib/docker vazio ou mover conteúdo temporariamente
    • Montar a partição/LV em /var/lib/docker
    • Iniciar Docker: sudo systemctl start docker
  • Rotação de logs (importantíssimo, evita “/var cheio”):
    • /etc/docker/daemon.json: { “log-driver”: “json-file”, “log-opts”: { “max-size”: “100m”, “max-file”: “5” }, “storage-driver”: “overlay2” }
    • sudo systemctl daemon-reload && sudo systemctl restart docker
  • journald: limite o espaço em /var/log/journal:
    • Em /etc/systemd/journald.conf, por exemplo: SystemMaxUse=1G SystemMaxFileSize=200M
    • sudo systemctl restart systemd-journald

Passo a passo (exemplo com LVM no mesmo disco de 200 GB) Atenção: adapte a nomenclatura do disco (em muitos casos o OS disk é /dev/sda). Se a VM já veio com partições padrão, considere adicionar um data disk novo e aplicar esses passos nele em vez de reprovisionar o OS disk.

  1. Criar partições (GPT, Gen2 com UEFI)
  • ESP (FAT32, 550 MB) — se já existir, não duplique
  • /boot (ext4, 1 GB)
  • PV LVM (restante do disco)

Exemplo com parted (ajuste o dispositivo!): sudo parted /dev/sda –script
mklabel gpt
mkpart ESP fat32 1MiB 551MiB
set 1 esp on
mkpart boot ext4 551MiB 1551MiB
mkpart lvm 1551MiB 100%

  1. Preparar sistemas de arquivos e LVM sudo mkfs.vfat -F32 /dev/sda1 sudo mkfs.ext4 /dev/sda2 sudo pvcreate /dev/sda3 sudo vgcreate vg0 /dev/sda3
  2. Criar LVs (ajuste tamanhos ao seu caso) sudo lvcreate -L 40G -n lv_root vg0 sudo lvcreate -L 8G -n lv_swap vg0 # ou 16G sudo lvcreate -L 120G -n lv_docker vg0 sudo lvcreate -L 8G -n lv_log vg0 sudo lvcreate -L 10G -n lv_home vg0

deixe ~10G livres no VG (não crie tudo de uma vez)

  1. Formatar e ativar sudo mkfs.ext4 /dev/vg0/lv_root sudo mkfs.ext4 /dev/vg0/lv_docker sudo mkfs.ext4 /dev/vg0/lv_log sudo mkfs.ext4 /dev/vg0/lv_home sudo mkswap /dev/vg0/lv_swap sudo swapon /dev/vg0/lv_swap
  2. Montagem e migração (se aplicável)
  • Monte em diretórios temporários, rsync de dados atuais (se já havia sistema), atualize /etc/fstab com as opções sugeridas e reinicie.
  • Para Docker, pare o serviço, mova conteúdo (se existir) e monte o LV em /var/lib/docker.

Boas práticas adicionais

  • fstrim: verifique se está ativo: systemctl status fstrim.timer (ative se necessário)
  • logrotate: garanta políticas para logs de app e do sistema
  • Monitoramento: crie alertas no Azure Monitor para:
    • Uso de disco do LV /var/lib/docker > 80%
    • Uso de inodes (df -i)
  • Segurança de montagem:
    • Noexec/nodev/nosuid em /tmp, /var/tmp, /var/log, /home (conforme sua necessidade)
    • Não aplique noexec em /var/lib/docker
  • Backups/snapshots: snapshots do disco gerenciado são úteis. Separar /var/lib/docker em um disco de dados ajuda a gerenciar snapshots independentemente do OS.

Quando separar ainda mais?

  • /opt: se você instala muitas ferramentas fora do gerenciador de pacotes (ex.: 5–10 GB)
  • /srv ou /data: se sua aplicação escreve dados persistentes fora de volumes Docker
  • /var/lib/postgresql, /var/lib/mysql: bancos de dados em partição/disk dedicado, com IOPS/latência melhores

Se quiser a solução mais simples possível

  • Use apenas /boot (1 GB), / (resto do disco), swap, e /tmp em tmpfs.
  • Ainda assim, configure a rotação de logs do Docker e journald para evitar que / encha.
  • Essa configuração é aceitável para ambientes de teste/dev ou produção com pouco footprint de Docker.

Quer que eu gere os comandos exatos adaptados à sua distro (Ubuntu, Debian, RHEL, etc.) e ao tipo de VM Azure (Gen1/Gen2)? Me diga:

  • Distro e versão
  • Tipo da VM (Gen1 BIOS ou Gen2 UEFI)
  • Tamanho de RAM
  • Se você pode anexar um disco de dados separado para o Docker (recomendado) ou se precisa ficar só no disco de 200 GB do SO

 

Prompt

Estou criando uma VM na Azure, com Linux. Estou com extrema dúvida com relação à configuração das partições do disco. Estou usando um disco de 250GB e pretendo rodar uma aplicação Python com Docker. Defina a melhor configuração das partições (/, /home, /boot, /tmp, /usr, /var, etc). Exemplifique comandos e ações na Azure Cloud.

ONE (Adapta)

Olá! Entendo perfeitamente sua dúvida. A configuração de partições é um ponto crucial para a estabilidade e performance de qualquer sistema Linux, especialmente quando se trata de cargas de trabalho como Docker, que podem consumir bastante espaço e I/O.

Vamos abordar as melhores práticas para sua VM Linux na Azure com um disco de 250GB, focando em uma aplicação Python com Docker.

🚀 Recomendações Iniciais e Contexto Azure

Antes de mergulharmos nas partições, é fundamental entender o contexto da Azure:

  1. Disco do SO (OS Disk): Na Azure, o disco do sistema operacional geralmente é gerenciado e otimizado para o boot e arquivos do sistema. Ele pode ter um custo por GB mais elevado que discos de dados. Para produção, é recomendado mantê-lo relativamente pequeno (ex: 64GB, 128GB) e usar discos de dados adicionais para cargas de trabalho de I/O intensas ou que exigem muito espaço.
  2. Discos de Dados (Data Disks): São discos adicionais que você anexa à VM. Eles oferecem maior flexibilidade, melhor performance de I/O (especialmente com Premium SSDs) e são ideais para /var/lib/docker, bancos de dados, logs pesados, etc. Para sua carga de trabalho com Docker, a melhor prática na Azure é usar um disco de dados separado para /var/lib/docker.
  3. Disco Temporário (Temporary Disk): Toda VM Azure tem um disco local efêmero (ex: /dev/sdb, montado em /mnt ou /mnt/resource). Ele é muito rápido, mas não persistente. Se a VM for realocada, reiniciada ou desligada (não apenas reboot), os dados neste disco podem ser perdidos. Use-o apenas para swap temporária, caches de build, logs efêmeros, etc. Nunca coloque dados persistentes ou /var/lib/docker nele.

🎯 Cenário Ideal (Recomendado): OS Disk Menor + Data Disk Dedicado para Docker

Este é o cenário mais robusto e performático para Docker na Azure.

1. VM na Azure: Criação e Anexação de Discos

Ao criar sua VM, você pode manter o disco de SO padrão (ex: 64GB, 128GB) e, após a criação, adicionar um novo disco de dados de 200GB (ou o tamanho que precisar para Docker).

Ações na Azure Cloud:

  • Criação da VM: Selecione sua imagem Linux preferida (Ubuntu Server, RHEL, CentOS, Debian) e o tamanho do disco do SO (padrão de 64GB ou 128GB é suficiente).
  • Anexar Data Disk (Portal Azure):
    1. Vá para sua VM no Portal Azure.
    2. No menu esquerdo, em “Configurações”, clique em “Discos”.
    3. Clique em “+ Criar e anexar um novo disco” ou “+ Anexar disco existente”.
    4. Configure o tamanho (ex: 200 GB), tipo de armazenamento (recomendo Premium SSD para Docker), e cache do host (defina para “Nenhum” ou “Read-only” para o disco do Docker, “Nenhum” é melhor para escritas pesadas).
    5. Clique em “Salvar”.

2. Configuração de Partições no Disco do SO (Ex: 64GB)

Assumindo que o disco do SO seja /dev/sda e você esteja usando uma VM Gen2 (UEFI):

  • Particionamento: Use LVM para maior flexibilidade.
  • Sistema de Arquivos: ext4 é o padrão e muito confiável.
  • Tamanhos Sugeridos:
    • /boot/efi: 550MB (FAT32) – Necessário para VMs Gen2 (UEFI).
    • /boot: 1GB (ext4) – Armazena o kernel e arquivos de boot.
    • swap: 8GB (Linux swap) – Geralmente 1x RAM até 16GB. Se usar disco temporário, pode ser menor aqui.
    • /: 40GB (ext4) – Raiz do sistema, contém /usr, /etc, etc.
    • /var/log: 8GB (ext4) – Logs do sistema.
    • /home: 10GB (ext4) – Diretórios de usuários.
    • VG Livre: ~5GB – Deixe espaço no Volume Group para futuros LVs.

Exemplo de Comandos (dentro da VM, como root ou com sudo):

  1. Identificar o disco: Use lsblk ou fdisk -l para ver seus discos. O disco do SO é geralmente /dev/sda.
  2. Particionar o disco do SO (ex: /dev/sda) com parted (para GPT/UEFI): 
    # Cuidado! Substitua /dev/sda pelo seu disco do SO se for diferente.
# Este comando apagará TUDO no disco. Faça em uma VM nova!
sudo parted /dev/sda --script \
  mklabel gpt \
  mkpart ESP fat32 1MiB 551MiB \
  set 1 esp on \
  mkpart boot ext4 551MiB 1551MiB \
  mkpart lvm ext4 1551MiB 100%
  3. Criar sistemas de arquivos para EFI e /boot: 
    sudo mkfs.vfat -F32 /dev/sda1 # Para /boot/efi
sudo mkfs.ext4 /dev/sda2     # Para /boot
  4. Configurar LVM no restante do disco: 
    sudo pvcreate /dev/sda3         # Criar Physical Volume
sudo vgcreate vg0 /dev/sda3     # Criar Volume Group (vg0 é um nome comum)
  5. Criar Logical Volumes (LVs) para o OS: 
    sudo lvcreate -L 40G -n lv_root vg0      # LV para /
sudo lvcreate -L 8G -n lv_swap vg0       # LV para swap
sudo lvcreate -L 8G -n lv_log vg0        # LV para /var/log
sudo lvcreate -L 10G -n lv_home vg0      # LV para /home
# Deixe espaço livre no vg0 para expansão futura
  6. Criar sistemas de arquivos nos LVs: 
    sudo mkfs.ext4 /dev/vg0/lv_root
sudo mkfs.ext4 /dev/vg0/lv_log
sudo mkfs.ext4 /dev/vg0/lv_home
sudo mkswap /dev/vg0/lv_swap

3. Configuração de Partições no Data Disk Dedicado (Ex: 200GB)

Assumindo que o Data Disk é /dev/sdc (o próximo disponível após /dev/sda e /dev/sdb – o temporário):

  • Particionamento: Use o disco inteiro ou LVM se planeja ter mais LVs nele futuramente. Para um único uso (/var/lib/docker), uma única partição primária é suficiente.
  • Sistema de Arquivos:
    • ext4: Simples e eficaz.
    • xfs: Excelente para cargas de trabalho com muitos arquivos pequenos ou arquivos grandes, como imagens Docker. Se usar XFS para Docker, é crucial formatar com ftype=1.

Exemplo de Comandos (dentro da VM):

  1. Identificar o Data Disk: Use lsblk ou fdisk -l. Ex: /dev/sdc.
  2. Particionar o Data Disk (ex: /dev/sdc): 
    # Para uma única partição cobrindo todo o disco
sudo parted /dev/sdc --script \
  mklabel gpt \
  mkpart primary ext4 0% 100% # Ou xfs
  3. Criar o sistema de arquivos: 
    # Opção 1: ext4 (simples)
sudo mkfs.ext4 /dev/sdc1

# Opção 2: xfs (recomendado para Docker) - IMPRESCINDÍVEL ftype=1 para overlay2
sudo mkfs.xfs -f -i ftype=1 /dev/sdc1
  4. Criar o ponto de montagem e montar: 
    sudo mkdir -p /var/lib/docker
# Se você já tem Docker instalado e em uso, precisará parar o serviço,
# mover o conteúdo existente de /var/lib/docker para um local temporário
# (ex: /tmp/docker_backup), montar o novo disco, e depois mover de volta.
sudo mount /dev/sdc1 /var/lib/docker

4. Configuração do /etc/fstab (Para ambos os discos)

É crucial adicionar as novas partições ao /etc/fstab para que sejam montadas automaticamente no boot. Use os UUIDs para garantir que a montagem seja robusta e não dependa da ordem dos discos.

  1. Obter UUIDs: 
    sudo blkid
  2. Exemplo de /etc/fstab: 
    # <file system>        <mount point>   <type>   <options>                               <dump> <pass>
UUID=xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx /boot/efi        vfat   umask=0077                              0 1
UUID=yyyyyyyy-yyyy-yyyy-yyyy-yyyyyyyyyyyy /boot            ext4   nodev,nofail                            0 2
UUID=zzzzzzzz-zzzz-zzzz-zzzz-zzzzzzzzzzzzz /                ext4   defaults,noatime,errors=remount-ro      0 1
UUID=aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa /var/log         ext4   nodev,nosuid,noexec,noatime             0 2
UUID=bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbbb /var/lib/docker  ext4   defaults,noatime                        0 2 # Ou xfs
UUID=cccccccc-cccc-cccc-cccc-cccccccccccc /home            ext4   nodev,nosuid,noatime                    0 2
/dev/vg0/lv_swap                         none             swap   sw                                      0 0
tmpfs                                    /tmp             tmpfs  defaults,size=4G,noexec,nodev,nosuid    0 0
    • noatime: Melhora a performance ao evitar atualizações de acesso a arquivos.
    • nodev, nosuid, noexec: Aumenta a segurança, impedindo execução de binários, uso de dispositivos ou setuid em partições específicas (especialmente tmp, var/log, home). NÃO use noexec em /var/lib/docker!
  3. Testar montagens: Após salvar fstab, execute sudo mount -a para testar. Se não houver erros, tudo está bem.

💻 Cenário Alternativo: Apenas um Disco de SO de 250GB

Se por algum motivo você não puder anexar um disco de dados separado e precisar usar o disco de 250GB para tudo, esta é a configuração recomendada, ainda com LVM.

1. Layout de Partições (com LVM) para 250GB

  • /boot/efi: 550MB (FAT32) – Para VMs Gen2 (UEFI).
  • /boot: 1GB (ext4) – Kernel e arquivos de boot.
  • swap: 8GB (Linux swap) – Ajuste à RAM da sua VM (1x RAM até 16GB é uma boa regra geral sem hibernação).
  • /: 50GB (ext4) – Raiz do sistema.
  • /var/lib/docker: 150GB (ext4 ou xfs) – Dedicado para imagens e volumes Docker.
  • /var/log: 8GB (ext4) – Logs do sistema.
  • /home: 10GB (ext4) – Diretórios de usuários.
  • VG Livre: ~20GB – Deixe espaço livre no Volume Group para futuras expansões.

2. Comandos de Particionamento e LVM

O processo é idêntico ao do cenário ideal, mas com os tamanhos ajustados e tudo no mesmo disco (/dev/sda).

  1. Particionar o disco (ex: /dev/sda) com parted: 
    # Cuidado! Substitua /dev/sda pelo seu disco do SO se for diferente.
sudo parted /dev/sda --script \
  mklabel gpt \
  mkpart ESP fat32 1MiB 551MiB \
  set 1 esp on \
  mkpart boot ext4 551MiB 1551MiB \
  mkpart lvm ext4 1551MiB 100%
  2. Criar sistemas de arquivos para EFI e /boot: 
    sudo mkfs.vfat -F32 /dev/sda1 # Para /boot/efi
sudo mkfs.ext4 /dev/sda2     # Para /boot
  3. Configurar LVM: 
    sudo pvcreate /dev/sda3
sudo vgcreate vg0 /dev/sda3
  4. Criar LVs: 
    sudo lvcreate -L 50G -n lv_root vg0
sudo lvcreate -L 8G -n lv_swap vg0
sudo lvcreate -L 150G -n lv_docker vg0
sudo lvcreate -L 8G -n lv_log vg0
sudo lvcreate -L 10G -n lv_home vg0
  5. Criar sistemas de arquivos nos LVs: 
    sudo mkfs.ext4 /dev/vg0/lv_root
sudo mkfs.ext4 /dev/vg0/lv_docker  # Ou mkfs.xfs -f -i ftype=1 /dev/vg0/lv_docker
sudo mkfs.ext4 /dev/vg0/lv_log
sudo mkfs.ext4 /dev/vg0/lv_home
sudo mkswap /dev/vg0/lv_swap
  6. Configurar /etc/fstab: O formato é o mesmo do cenário ideal, apenas os UUIDs e tamanhos de LV serão diferentes. 
    # Exemplo (substitua UUIDs)
UUID=xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx /boot/efi        vfat   umask=0077                              0 1
UUID=yyyyyyyy-yyyy-yyyy-yyyy-yyyyyyyyyyyy /boot            ext4   nodev,nofail                            0 2
UUID=zzzzzzzz-zzzz-zzzz-zzzz-zzzzzzzzzzzzz /                ext4   defaults,noatime,errors=remount-ro      0 1
UUID=aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa /var/log         ext4   nodev,nosuid,noexec,noatime             0 2
UUID=bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbbb /var/lib/docker  ext4   defaults,noatime                        0 2
UUID=cccccccc-cccc-cccc-cccc-cccccccccccc /home            ext4   nodev,nosuid,noatime                    0 2
/dev/vg0/lv_swap                         none             swap   sw                                      0 0
tmpfs                                    /tmp             tmpfs  defaults,size=4G,noexec,nodev,nosuid    0 0

🐳 Configuração Específica para Docker

Independentemente do cenário de disco, estas configurações são cruciais para o Docker:

  1. Verificar Driver de Armazenamento: O Docker moderno usa overlay2 por padrão, que é eficiente. Verifique com docker info | grep "Storage Driver".
  2. Rotação de Logs dos Containers: Impedir que logs de containers encham o disco é vital. Crie ou edite o arquivo /etc/docker/daemon.json: 
    {
  "log-driver": "json-file",
  "log-opts": {
    "max-size": "100m",
    "max-file": "5"
  },
  "storage-driver": "overlay2"
}

    Isso limita cada log de container a 100MB e mantém um máximo de 5 arquivos de log (total de 500MB por container).

  3. Reiniciar Docker para aplicar as mudanças: 
    sudo systemctl daemon-reload
sudo systemctl restart docker

🧹 Limpeza e Boas Práticas Adicionais

  • fstrim: Ative o serviço fstrim.timer para garantir que o Linux notifique o Azure sobre blocos não utilizados, permitindo a recuperação de espaço em discos gerenciados. 
    sudo systemctl enable fstrim.timer
sudo systemctl start fstrim.timer
  • /tmp em tmpfs: Montar /tmp como tmpfs (sistema de arquivos baseado em RAM) é rápido, seguro e não consome espaço em disco persistente. Já está incluído nos exemplos de fstab. Ajuste size=4G conforme a RAM da sua VM.
  • Journald: Limite o tamanho dos logs do journald em /etc/systemd/journald.conf para evitar que /var/log (ou /) encha: 
    [Journal]
SystemMaxUse=1G   # Máximo de 1GB para logs do sistema
SystemMaxFileSize=200M # Máximo de 200MB por arquivo de log

    Após editar, reinicie: sudo systemctl restart systemd-journald.

  • Monitoramento: Use o Azure Monitor para criar alertas de uso de disco (especialmente /var/lib/docker e /) para que você seja notificado antes que o espaço se esgote.

Espero que este guia detalhado ajude você a configurar suas partições de forma otimizada na Azure! A escolha entre usar um único disco ou um disco de dados separado para Docker é importante, e o cenário com o disco de dados dedicado é geralmente a melhor opção para produção e escalabilidade.

Se tiver mais perguntas ou quiser adaptar algo para uma distribuição Linux específica, me diga! 😊