tini
v0.19.0
init pequeno, mas válido para contêineres Tini é o init mais simples que você poderia pensar.
Tudo o que Tini faz é gerar uma única criança (o Tini deve ser executado em um contêiner) e aguarde a saída o tempo todo, colhendo zumbis e realizando o encaminhamento de sinal.
Usar Tini tem vários benefícios:
SIGTERM encerra corretamente seu processo, mesmo que você não instalasse explicitamente um manipulador de sinal para ele.Se você deseja mais detalhes sobre por que isso é útil, revise esta discussão sobre o problema: o que é vantagem do Tini?.
NOTA: Se você estiver usando o Docker 1.13 ou maior, o TINI estará incluído no próprio Docker. Isso inclui todas as versões do Docker CE. Para ativar o Tini, basta passar a bandeira --init para docker run .
Nota: Existem imagens pré-construídas do Docker disponíveis para TINI. Se você estiver usando uma imagem do Ubuntu ou do CentOS como base, poderá usar um deles como substituição.
Nota: Existem pacotes de tini para Linux Alpine e Nixos. Veja abaixo as instruções de instalação.
Adicione TINI ao seu contêiner e faça -o executável. Em seguida, basta invocar Tini e aprovar seu programa e seus argumentos como argumentos para Tini.
No Docker, você deseja usar um ponto de entrada para não precisar se lembrar de invocar manualmente o TINI:
# Add Tini
ENV TINI_VERSION v0.19.0
ADD https://github.com/krallin/tini/releases/download/${TINI_VERSION}/tini /tini
RUN chmod +x /tini
ENTRYPOINT ["/tini", "--"]
# Run your program under Tini
CMD ["/your/program", "-and", "-its", "arguments"]
# or docker run your-image /your/program ...
Observe que você pode pular as -- sob certas condições, mas também pode sempre incluí -lo para ser seguro. Se você vir uma mensagem de erro que se parece com tini: invalid option -- 'c' , precisará adicionar o -- .
Os argumentos para Tini devem ser passados como -v no exemplo a seguir: /tini -v -- /your/program .
Nota: O binário vinculado acima é um binário ligado dinamicamente de 64 bits.
Os binários tini e tini-static são assinados usando a chave 595E85A6B1B4779EA4DAAEC70B588DFF0527A9B7 .
Você pode verificar suas assinaturas usando gpg (que você pode instalar usando o gerenciador de pacotes):
ENV TINI_VERSION v0.19.0
ADD https://github.com/krallin/tini/releases/download/${TINI_VERSION}/tini /tini
ADD https://github.com/krallin/tini/releases/download/${TINI_VERSION}/tini.asc /tini.asc
RUN gpg --batch --keyserver hkp://keyserver.ubuntu.com:80 --recv-keys 595E85A6B1B4779EA4DAAEC70B588DFF0527A9B7
&& gpg --batch --verify /tini.asc /tini
RUN chmod +x /tini
Os binários tini e tini-static geraram somas de verificação ( SHA1 e SHA256 ).
Você pode verificar as somas de verificação usando sha1sum e sha256sum (que você pode instalar usando o gerenciador de pacotes):
ENV TINI_VERSION v0.19.0
RUN wget --no-check-certificate --no-cookies --quiet https://github.com/krallin/tini/releases/download/${TINI_VERSION}/tini-amd64
&& wget --no-check-certificate --no-cookies --quiet https://github.com/krallin/tini/releases/download/${TINI_VERSION}/tini-amd64.sha256sum
&& echo "$(cat tini-amd64.sha256sum)" | sha256sum -c
No Alpine Linux, você pode usar o seguinte comando para instalar o tini:
RUN apk add --no-cache tini
# Tini is now available at /sbin/tini
ENTRYPOINT ["/sbin/tini", "--"]
Usando o NIX, você pode usar o seguinte comando para instalar o tini:
nix-env --install tini
No Debian (Buster ou mais recente), você pode usar o seguinte comando para instalar o tini:
apt-get install tini
Observe que isso instala /usr/bin/tini (e /usr/bin/tini-static ), não /tini .
No Arch Linux, há um pacote disponível na AUR. Instale usando as instruções oficiais ou use um ajudante AUR:
pacaur -S tini
Os binários de braço e 32 bits estão disponíveis! Você pode encontrar a lista completa dos binários disponíveis na guia Releases.
O argumento -v pode ser usado para saída verbosa extra (você pode passar até 3 vezes, por exemplo, -vvv ).
Por padrão, o TINI precisa ser executado como PID 1 para que ele possa colher zumbis (executando como PID 1, os zumbis são parentados em Tini).
Se, por algum motivo, você não puder executar o tini como PID 1, registrar TINI como um sub -mais de processo (apenas em Linux> = 3,4), por: qualquer: qualquer: qualquer: qualquer:
-s para tini ( tini -s -- ... )export TINI_SUBREAPER= TINI_SUBREAPERIsso garantirá que os zumbis sejam destacados para Tini, apesar de Tini não funcionar como PID 1.
NOTA: O TINI emitirá um aviso se detectar que não está sendo executado como PID 1 e não estiver registrado como um sub -melhor. Se você não vê um aviso, você está bem.
Tini reutilizará o código de saída da criança ao sair, mas ocasionalmente, pode não ser exatamente o que você deseja (por exemplo, se seu filho sair com 143 depois de receber o SigMert). Notavelmente, isso pode ser um problema nos aplicativos Java.
Nesse caso, você pode usar o sinalizador -e para remapear um código de saída arbitrário para 0. Você pode passar o sinalizador várias vezes, se necessário.
Por exemplo:
tini -e 143 -- ...
Por padrão, Tini apenas mata seu processo infantil imediato. Isso pode ser inconveniente se o envio de um sinal para esse processo não tiver o efeito desejado. Por exemplo, se você fizer
docker run krallin/ubuntu-tini sh -c 'sleep 10'
E Ctrl-C, nada acontece: o SIGINT é enviado ao processo 'Sh', mas esse shell não reagirá a ele enquanto aguarda o fim do 'sono'.
Com a opção -g , Tini mata o grupo de processos infantis, para que todos os processos do grupo recebam o sinal. Isso corresponde mais ao que acontece quando você faz Ctrl-C etc. em um terminal: o sinal é enviado para o grupo de processos em primeiro plano.
O Tini pode definir seu sinal de morte dos pais, que é o sinal que o tini deve receber quando seus pais saem. Para definir o sinal de morte dos pais, use o sinalizador -p com o nome do sinal Tini deve receber quando o pai sair:
tini -p SIGTERM -- ...
Nota: Consulte esta discussão sobre relações públicas para saber mais sobre o sinal de morte dos pais e os casos de uso.
O TINI também pode ser usado com um ponto de entrada existente em seu contêiner!
Supondo que seu ponto de entrada fosse /docker-entrypoint.sh , você usaria:
ENTRYPOINT ["/tini", "--", "/docker-entrypoint.sh"]
Tini tem muito poucas dependências (depende apenas da libc), mas se o seu contêiner não começar, considere usar a versão estaticamente construída:
ADD https://github.com/krallin/tini/releases/download/${TINI_VERSION}/tini-static /tini
O TINI é um arquivo muito pequeno (na faixa de 10kb), por isso não adiciona muito peso ao seu contêiner.
A versão estaticamente ligada é maior, mas ainda <1m.
Se você preferir não fazer o download do binário, poderá construir Tini executando cmake . && make .
Antes de construir, você provavelmente também deseja correr:
export CFLAGS="-DPR_SET_CHILD_SUBREAPER=36 -DPR_GET_CHILD_SUBREAPER=37"
Isso garante que, mesmo se você estiver construindo em um sistema que tenha cabeçalhos de kernel linux antigos (<3,4), o TINI será construído com o suporte de sub -melhor da criança. Geralmente, é isso que você deseja se você usar o Tini com o Docker (se o seu kernel host suportar o Docker, ele também deve apoiar o Sub -Rapers Child).
Depois de gerar seu processo, o TINI aguardará sinais e os encaminhará para o processo filho e colherá periodicamente os processos de zumbi que podem ser criados dentro do seu contêiner.
Quando o "primeiro" processo infantil sai ( /your/program nos exemplos acima), também sai do código de saída do processo filho (para que você possa verificar o código de saída do seu contêiner para saber se a criança saiu com sucesso).
Se algo não estiver funcionando exatamente como você espera, considere aumentar o nível de verbosidade (até 3):
tini -v -- bash -c 'exit 1'
tini -vv -- true
tini -vvv -- pwd
Mantenedor:
Colaboradores:
Agradecimentos especiais a:
