QF0's questions

Estou usando este pipeline para gravar um arquivo de imagem para dirigir $drive:

wget -o logfile -O - https://route/to/image.gz | \
         gunzip -c | \
         dd of="$drive" bs=4M conv=fdatasync 2>/dev/null

logfileé criado para monitorar o progresso.

Tenho um mau pressentimento sobre isso e não consigo me convencer de que é infalível. A imagem em si é sempre um múltiplo de 4 MB, então isso não é um problema, mas ddé potencialmente problemático (veja esta resposta da U&L , por exemplo).

Estou sendo paranoico ou existe uma maneira melhor de fazer isso?

EDITAR

Seguindo os comentários (obrigado), eu fiz um benchmarking head -ce dd bs=1para escrever uma imagem em uma unidade. TL;DR: ddé basicamente inútil nesta aplicação. A imagem no servidor remoto compacta em gzip para cerca de 46M, então ddé usada com bs=1, então isso talvez seja um pouco injusto com dd. A imagem é recuperada com wget, gunzipada na hora e então gravada na unidade com head -cou dd bs=1:

Opção 1:

# time wget -o logfile -O - https://path/to/foo.img.gz | \
       gunzip -c | \
       dd of=/dev/sda bs=1 conv=fdatasync 2>/dev/null
    real    1m55.665s
    user    0m32.323s
    sys     2m20.841s

Opção 2:

# time wget -o logfile -O - https://path/to/foo.img.gz | \
       gunzip -c | \
       cat > /dev/sda 2>/dev/null
    real    0m7.419s
    user    0m0.646s
    sys     0m0.507s

Ambas as opções foram testadas obtendo-se o md5sumand sha256sumdos primeiros 48159047 bytes da unidade, e ambas forneceram a pré-compressão correta md5sum, sha256sumconforme encontrado no servidor:

# time head -c 48159047 /dev/sda | md5sum
b3df12b61df3121ad112f825cc6fe8b7  -

real    0m0.222s
user    0m0.075s
sys     0m0.049s

# time dd status=none if=/dev/sda bs=1 count=48159047 | md5sum
b3df12b61df3121ad112f825cc6fe8b7  -

real    1m31.627s
user    0m49.218s
sys     1m45.406s

Os sha256sumresultados foram praticamente os mesmos: cerca de 0,25 s de tempo real para head -c, e 1 m32 s para dd.

Preciso confirmar que nenhuma parte de um disco está montada antes de sobrescrever o disco inteiro . O problema aqui é que parece que você tem que saber os nomes de quaisquer sistemas de arquivos no disco antes de verificá-los individualmente, e isso pode ser difícil em geral.

Por exemplo, o sistema no qual estou escrevendo isso tem um SSD e parted -lmostra esse disco como /dev/nvme0n1, tamanho 500G. /dev/blockmostra:

lrwxrwxrwx  1 root root   10 Nov 18 12:37 259:0 -> ../nvme0n1
lrwxrwxrwx  1 root root   12 Nov 18 12:37 259:1 -> ../nvme0n1p1
lrwxrwxrwx  1 root root   12 Nov 18 12:37 259:2 -> ../nvme0n1p2

O número menor 0 é então o 'disco inteiro', enquanto 1 é a partição de boot e 2 é a partição de swap. Este SSD é configurado para LVM, mas os dispositivos LVM têm /dev/mappernomes completamente diferentes.

A palavra nvme0n1não aparece em lugar nenhum quando você verifica sistemas de arquivos montados ( mount, findmnt nvme0n1, /proc/mounts, /etc/mtab). A palavra nvme0n1p1 aparece , mas apenas porque é uma partição de inicialização montada ( /boot/efi). Em geral, o disco que estou olhando pode não ter uma partição de inicialização, então procurar por nvme0n1como prefixo pode não ser útil (e mesmo se eu encontrasse uma palavra com o prefixo correto, tenho garantia de que ela está na mesma unidade?)

Existe alguma maneira genérica de descobrir se um disco está 'em uso'? Neste caso em particular, posso analisar a lsblksaída para encontrar os /dev/mappernomes em nvme0n1, mas isso não parece ser uma boa solução a longo prazo.

Eu tenho um script complexo onde geralmente testo cada comando individualmente para obter sucesso. Porém, há casos em que tenho que realizar uma sequência de operações simples e prefiro obter um status de saída de toda a sequência, sem me preocupar em verificar cada comando individualmente.

Esta é minha primeira tentativa, com alguns comandos arbitrários:

#!/bin/bash
if ! (
    set -e
    cd test
    touch foo
    chown root:root foo)
then
    echo "subshell failed"
else
    echo "subshell completed"
fi

O set -eobjetivo era garantir que o subshell saísse com falha quando a primeira falha fosse encontrada, mas isso não funciona. Nesse caso, se o diretório testnão existir, o script simplesmente cria foono diretório atual e falha no arquivo chown.

Qual é a maneira certa de fazer isso? Em outras palavras, echo 'subshell concluído' somente se todos os 3 comandos forem concluídos sem erros?

Eu tenho uma sshdconfiguração parecida com esta:

DenyUsers  *
AllowUsers root@*
AllowUsers user1@*
AllowUsers user2@*

Os documentos sshd afirmam que "As diretivas de permissão/negação de usuários são processadas na seguinte ordem: DenyUsers, AllowUsers", e a intenção aqui é que ninguém tenha permissão para usar sshalém dos três usuários listados.

No entanto, isso não funciona: se algum desses usuários tentar se conectar ssh, os logs ( systemctl status ssh) informam que "Usuário foo do abcd não permitido porque listado em DenyUsers".

Então parece que DenyUserssempre tem prioridade (estou no OpenSSH_8.9p1, no Ubuntu 22.04).

Existe alguma maneira de contornar isso? Eu preciso de alguma forma DenyUsersporque a configuração deste sistema é automatizada e todos os três usuários podem ter acesso negado comentando seus dados individuais AllowUsers, o que daria:

# AllowUsers root@*
# AllowUsers user1@*
# AllowUsers user2@*

O problema agora é que todos têm acesso, e não ninguém.

Estou instalando Java e Tomcat em um servidor headless. O cliente não possui Java e apenas vê uma página da web.

Devo instalar o openjdk-17 ou o openjdk-17-headless?