teeeeee's questions

Tenho um script de shell no meu host, que está chamando outro script para rodar dentro do contêiner. Aqui está um caso simples que funciona bem:

host_script.sh

#!/bin/sh

results=$(docker exec mycontainer "./scripts/container_script.sh")
echo $results

container_script.sh

#!/bin/sh

echo "Hello World"

No entanto, agora eu gostaria de executar o script do container com um argumento de entrada. Assim:

host_script.sh

#!/bin/sh

path="/some/other/path"
results=$(docker exec mycontainer "./scripts/container_script.sh $path")
echo $results

container_script.sh

#!/bin/sh

echo "Hello World"
echo $1

Desta vez recebo o erro:

OCI runtime exec falhou: exec falhou: não foi possível iniciar o processo do contêiner: exec: "./scripts/container_script.sh /some/other/path": stat ./scripts/container_script.sh /some/other/path: arquivo ou diretório inexistente: desconhecido

Como posso passar um argumento para este script dentro do contêiner?

Gostaria de executar um script em uma máquina host ( script_on_host.sh), que então alcança dentro de um contêiner docker para obter alguns dados usando um segundo script (script_in_container.sh). Os dados estão disponíveis somente dentro do contêiner, e não diretamente do host, daí o motivo de fazer dessa forma.

Estou com problemas para passar dados entre os dois scripts. Tentei o seguinte:

script_em_container.sh

#!/bin/bash

x=1
y=2
z=6.3
echo $x
echo $y
echo $z

script_no_host.sh

#!/bin/bash

results=$(docker exec mycontainer './script_in_container.sh')
X=$results(1)
Y=$results(2)
Z=$results(3)

Mas ele gera um erro. Alguém pode me ajudar com isso? Existe uma maneira legal ou mais padrão de passar variáveis ​​dessa forma? Sinto que talvez esteja fazendo algo um pouco desajeitado aqui, usando echo para imprimir várias linhas do script do contêiner.

Tenho um objeto json que tem um número desconhecido de variáveis, assim:

{ 
  "var1": 123, 
  "var2": 456, 
  "var3": 789 
}

Como posso convertê-lo automaticamente para formar a seguinte string?

'var1=123,var2=456,var3=789'

Observe que estou procurando uma solução que não exija a instalação do jq.

Criei esta estrutura de diretório simples:

$ tree testdir/
testdir/
├── subdir1
│   ├── file1.txt
│   └── file2.txt
├── subdir2
│   ├── file3.txt
│   └── file4.txt

e gostaria de arquivar o conteúdo de testdir em um arquivo tar. Então eu executo o seguinte comando (note que o exclude é por causa desta resposta ):

tar cvf /home/myuser/testdir/testdir_tarfile.tar --exclude=/home/myuser/testdir/testdir_tarfile.tar /home/myuser/testdir

Agora eu quero extrair os arquivos (junto com a estrutura de diretórios deles) mais uma vez. Então, primeiro crie um diretório de destino:

$ mkdir /home/myuser/testdir/target_dir

e agora extraia o arquivo tar para o diretório de destino:

tar xf /home/myuser/testdir/testdir_tarfile.tar -C /home/myuser/testdir/target_dir/

A estrutura do arquivo resultante se parece com isto:

$ tree testdir/
testdir/
├── subdir1
│   ├── file1.txt
│   └── file2.txt
├── subdir2
│   ├── file3.txt
│   └── file4.txt
├── target_dir
│   └── home
│       └── myuser
│           └── testdir
│               ├── subdir1
│               │   ├── file1.txt
│               │   └── file2.txt
│               └── subdir2
│                   ├── file3.txt
│                   └── file4.txt
└── testdir_tarfile.tar

Por que o diretório de destino agora contém subpastas "home" e "myuser"? Eu gostaria que ele contivesse apenas "subdir1" e "subdir2", ou seja, como o diretório original arquivado.

Tenho um aplicativo que faz backups diários automáticos às 23h em um diretório dirA. Cada backup é um único arquivo .tar e tem uma convenção de nomenclatura aparentemente aleatória sobre a qual não tenho controle (por exemplo 129d3139.tar, , 4a98bb6b.tar, etc).

Como dirAreside em um meio de armazenamento que é muito limitado em espaço, tenho um cron job cinco minutos depois, às 23h05, que exclui todos os backups, exceto o mais recente. O script bash " clear_old_backups.sh" se parece com isso e funciona bem (graças a esta resposta ):

#!/usr/bin/env bash

find /path/to/dirA/ -type f -printf '%T@\t%p\n' |
sort -t $'\t' -g |
head -n -1 |
cut -d $'\t' -f 2- |
xargs -r rm

Agora, além disso, estou procurando manter alguns backups arquivados mais antigos em outro meio de armazenamento maior, em um segundo diretório dirB. Idealmente, dentro, dirBeu gostaria de ter arquivos x4:

1 dia de idade (apenas uma cópia direta do único armazenado em dirA), depois adicionalmente 1 semana de idade, 1 mês de idade e 6 meses de idade.

Alguém pode ajudar com um script bash que copie e mantenha os arquivos de backup relevantes?

Não tenho certeza por onde começar - preciso de alguma forma verificar com muito mais regularidade se o timestamp de um arquivo atingiu "agora menos 7 dias", etc? E só então agir de acordo?

O sistema operacional é Debian 12.

Gostaria de um script de shell bash (para meu sistema Debian 12) que aceitasse múltiplos caminhos como argumentos e, então, verificasse se um arquivo pode ser criado com sucesso em cada um deles. Então, o resultado deveria ser colocado no formato json.

O comando a ser executado deve ser:

./checkavailable.sh /the/first/path /the/second/path

(onde pode haver qualquer número de caminhos de entrada fornecidos, mas pelo menos um) e eu gostaria que a saída estivesse no seguinte formato:

[
  { "is_available": 0, "path": "/the/first/path/" },
  { "is_available": 1, "path": "/the/second/path/" }
]

Atualmente, consegui fazer isso com o seguinte script:

#!/bin/bash

# Check if first path is available
if touch $1/checkalivefile ; then
    avail_path1=1
    rm $1/checkalivefile
else
    avail_path1=0
fi

# Check if second path is available
if touch $2/checkalivefile ; then
    avail_path2=1
    $2/checkalivefile
else
    avail_path2=0
fi

echo "["
printf "  { \"is_available\": "$avail_path1", \"path\": \"$1\" } "
printf ",\n"
printf "  { \"is_available\": "$avail_path2", \"path\": \"$2\" } "
echo
echo "]"

mas é obviamente um pouco primitivo e é codificado para funcionar apenas com argumentos x2, e não é escalável para argumentos adicionais.

Eu poderia tentar adicionar um loop agora. No entanto, me deparei com este script, que parece fazer algo similar (para obter o uso do disco neste caso), mas usando awk em vez de um loop:

#!/bin/bash

echo "["
du -s -B1 "$@" | awk '{if (NR!=1) {printf ",\n"};printf "  { \"dir_size_bytes\": "$1", \"path\": \""$2"\" }";}'
echo
echo "]"

Alguém pode mostrar como essa abordagem usando "awk" pode ser aplicada ao meu caso? Sou muito novo em scripts bash, então espero aprender alguma coisa.

Quero detectar se existe um de cada um dos seguintes tipos de arquivo em um diretório .png, .txte .tar.gz.

O seguinte funciona corretamente ao testar dois deles

shopt -s nullglob
MYDIR=/some_dir
if [ $MYDIR/*.png] && [ $MYDIR/*.txt]; then
  echo "All files present"
else
  echo "At least one type is missing"
fi

Mas se eu tentar testar todos os três usando

if [ $MYDIR/*.png] && [ $MYDIR/*.txt] && [ $MYDIR/*.tar.gz]; then
...

ou usando

if [[ $MYDIR/*.png && $MYDIR/*.txt && $MYDIR/*.tar.gz ]]; then
...

então não obtenho o comportamento correto (ele ainda retorna verdadeiro mesmo se um dos arquivos estiver faltando).

O que está acontecendo aqui?

Sou iniciante em Linux e preciso de ajuda para criar um script bash para criar um arquivo com uma data específica no nome do arquivo.

Tenho um diretório chamado /backups/, no qual gostaria de criar um arquivo de acordo com a data e hora atuais com algum texto de prefixo, como /backups/backup_2023_09_15_14_00_00.txt. Essa parte já está respondida aqui ).

O problema é que desejo remover o arquivo de backup anterior se já existir um (que seria nomeado de acordo com o formato backup_****_**_**_**_**_**.txt) e se a criação do novo arquivo foi bem-sucedida.

Existe uma maneira de fazer algo assim?

Estou observando o seguinte comportamento e quero saber se ele é esperado.

Estou tentando executar o uso do disco ( du) como user2em um diretório test_directoryque pertence a user1.

Se eu alterar as permissões para permitir acesso total a todos (usando chmod 777 test_directory), ambos user1e user2poderão ver corretamente o uso do disco, conforme o esperado:

No entanto, se eu restringir o acesso executável para outros usuários (usando chmod 776 test_directory), user2não será possível executar due ocorrerá um erro de permissão:

Além disso, o diretório mostra como tendo tamanho de 4096 bytes no caso do erro.

1. Por que as permissões executáveis ​​são necessárias para que um usuário possa solicitar o uso do disco com du? Eu teria ingenuamente esperado que apenas permissões de leitura fossem necessárias (ou seja, chmod 774). Na verdade, parece que as permissões de leitura e execução são necessárias para executar du (ou seja chmod 775).

2. Por que o tamanho padrão do diretório é de 4096 bytes neste caso?

Obrigado!