Show HN: #!/usr/bin/env docker run

 (gist.github.com/adtac)
15 pontos por GN⁺ 2024-01-15 | 7 comentários | Compartilhar no WhatsApp

O que é #!?

  • #! (pronunciado shebang) é uma convenção no Unix, usada principalmente para linguagens de script como Python ou Bash
  • Apresenta um caso de uso que aproveita isso para empacotar, em um único arquivo, uma forma de distribuir aplicações de modo cross-platform e em várias distribuições Linux
  • O Dockerfile de exemplo configura um servidor full stack completo, incluindo backend, banco de dados e UI, tudo em um único arquivo
  • É semelhante ao Cosmopolitan Libc, mas voltado para empacotamento de aplicações

Por que usar?

  • Por que não usar?

É seguro?

  • Provavelmente não.

Devo usar?

  • Se quiser, pode usar.

Tem bom desempenho?

  • Possivelmente.

Dá para manter?

  • Não.

Funciona?

  • Sim.

Como executar?

  • Pode ser executado com o seguinte comando: chmod +x ./Dockerfile ./Dockerfile
  • Depois disso, acesse http://127.0.0.1:8080.

Opinião do GN⁺

  • Este artigo apresenta uma forma única de empacotar um servidor full stack em um único Dockerfile usando #! (shebang).
  • Desperta curiosidade técnica e propõe uma nova abordagem para métodos tradicionais de deploy de aplicações.
  • Embora essa abordagem não seja recomendada em termos de manutenção e estabilidade, ela pode ser uma alternativa interessante para desenvolvedores interessados em projetos experimentais e inovadores.

Leituras relacionadas

7 comentários

 
minhoryang 2024-01-17

Para usar heredoc como <<EOF, é necessário ter # syntax = docker/dockerfile:1.4.0 no topo do Dockerfile. Surpreendentemente, o syntax também é obtido do Docker registry.
 
pmc7777 2024-01-16

Uau... esse foi o maior choque mental do ano kkkkkkkkkkk
 
arfwene 2024-01-15

Que jeito divertido.
 
bbulbum 2024-01-15

kkkk... bem criativo mesmo
 
sagee 2024-01-15

Uau... isso é bem original. É como descobrir a combinação de aço e concreto... ok, talvez isso seja um pouco de exagero, mas gostei.
O fato de esse truque funcionar desse jeito porque, justamente na hora certa, #! no Dockerfile acaba sendo tratado como comentário com #...
Daqui pra frente, acho que vou colocar isso no Dockerfile em vez de usar um arquivo separado tipo build-run-test.sh.
 
GN⁺ 2024-01-15
Comentários do Hacker News

  • Exemplo de uso de shebang com nix-shell

    • Explica como usar o shebang do nix-shell para criar um script executável com todas as dependências necessárias incluídas.
    • Fornece um exemplo de script em Python que reduz uma imagem em 50%.
    • Ao dar permissão de execução ao script (chmod +x), ele se torna um executável com as dependências especificadas.

  • Opção -S / --split-string do /usr/bin/env

    • Explicação sobre a opção -S, disponível desde o GNU Coreutils 8.30.
    • Essa opção depende de um comportamento não padronizado e só funciona em sistemas operacionais que tratam todo o texto como argumentos do executável.
    • Esse comportamento não padronizado funciona na maioria dos GNU/Linux modernos, BSDs e macOS.

  • Docker e compatibilidade de arquitetura

    • Aponta que o Docker, na prática, precisa de uma VM Linux em plataformas que não sejam Linux.
    • Contêineres Linux são excelentes, mas é difícil considerar o Docker uma solução realmente multiplataforma.

  • Opiniões sobre aplicações de arquivo único

    • Elogia a ideia de incluir a aplicação inteira em um único arquivo.
    • Critica a complexidade do Docker e questiona o uso de contêineres para segurança ou controle de versão.
    • Pergunta se o WebAssembly (WASM) poderia resolver esses problemas.

  • Menção a Podman e bubblewrap como alternativas ao Docker

    • Menciona que pode ser melhor usar Podman ou bubblewrap em vez de Docker.
    • O Podman depende um pouco mais de distribuições específicas, e o bubblewrap pode não estar incluído em algumas distribuições por questões de segurança.

  • Projetos de arquivo único com heredocs

    • Mesmo sem um shebang engenhoso, é possível criar projetos de arquivo único para qualquer linguagem ou infraestrutura usando heredocs.
    • Fornece um exemplo do mesmo app empacotado como script bash.

  • Crítica à obsessão por “arquivo único”

    • Aponta que, em vez de empacotar tudo em um único arquivo, é possível usar um diretório para criar aplicações autocontidas.
    • Observa que transformar algo em arquivo único não é necessariamente a melhor abordagem.

  • Padrão de script autoconsumido

    • Explica como embutir scripts de outro interpretador dentro do próprio script e usar sed para extrair o script entre tags.
    • Reconhece que essa abordagem às vezes pode ser muito útil, mas também pode ficar complexa.

  • Como usar guix shell na posição de shebang

    • Fornece um exemplo com guix shell retirado do manual do Guix.
    • Funciona junto com um arquivo de manifesto para especificar ambientes mais complexos.

  • Dockerfile que compila e executa a si próprio

    • Fornece uma explicação e um exemplo de código de um Dockerfile que compila e executa a si próprio, escrito em novembro de 2021.