Confira!!
Nos últimos meses, Lennart Poettering vem trabalhando em um conceito de "serviços portáteis" e esse novo recurso de grande porte já chegou ao Systemd. Os serviços portáteis são semelhantes aos contêineres, mas diferentes.
O Portable Services é um grande acréscimo ao systemd em cerca de seis mil novas linhas de código para este sistema init e também traz o novo utilitário portablectl . Para a explicação dos serviços portáteis do systemd, aqui está como a documentação descreve-o com o código que pousou esta manhã no systemd Git :
Esta versão do systemd inclui uma prévia do conceito "serviço portátil". "Serviços portáteis" devem ser uma melhoria incremental em relação aos serviços de sistema tradicionais, tornando mais prontamente disponíveis dois aspectos específicos do gerenciamento de contêineres para os serviços do sistema. Especificamente:
1. O agrupamento de aplicativos, ou seja, empacotar vários serviços, seus binários e todas as suas dependências em uma única imagem e executá-los diretamente a partir dele.
2. Políticas de segurança padrão mais rigorosas, por exemplo, sand-boxing de aplicativos.
A principal ferramenta para interface com "serviços portáteis" é o novo programa "portablectl". É atualmente enviado em / usr / lib / systemd / portablectl (ou seja, não no `$ PATH`), já que ainda não é considerado parte das interfaces systemd suportadas oficialmente - é uma prévia ainda afinal.
Os serviços portáteis não trazem nada inerentemente novo à tabela. Tudo o que eles fazem é reunir conceitos conhecidos de uma maneira um pouco mais agradável para abordar um conjunto específico de casos de uso de uma maneira mais agradável.
# Então, o que * é * um "Serviço Portátil"?
Em última análise, um serviço portátil é apenas uma árvore do SO, dentro de uma árvore de diretórios ou dentro de uma imagem de disco bruta que contém um sistema de arquivos do Linux. Esta árvore é chamada de "imagem". Pode ser "anexado" ou "desconectado" do sistema. Quando unidades systemd específicas "anexadas" da imagem são disponibilizadas no sistema host, elas se comportam exatamente como os serviços do sistema instalados localmente. Quando "desanexados", essas unidades são removidas novamente do host, não deixando nenhum artefato por perto (exceto talvez as mensagens que eles possam ter logado).
A árvore / imagem do sistema operacional pode ser criada com qualquer ferramenta de sua escolha. Por exemplo, você pode usar `dnf --installroot =` se quiser, ou `debootstrap`, o formato da imagem é inteiramente genérico e não precisa carregar nenhum metadado específico além do que as imagens de distribuição carregam de qualquer maneira. Ou para dizer isso de maneira diferente: o formato da imagem não define nenhum novo metadado, pois os arquivos de unidade e os diretórios de árvore do SO ou as imagens de disco já são suficientes e estão disponíveis universalmente nos dias de hoje. Uma ferramenta particularmente interessante para criar imagens adequadas é o mkosi , mas muitas outras ferramentas existentes também funcionarão.
Se você quiser, "Serviços portáteis" é uma maneira mais agradável de gerenciar ambientes chroot (), com melhor segurança, ferramentas e comportamento.
# Onde está a diferença para um "contêiner"?
"Container" é um termo muito vago, afinal ele é usado para contêineres de sistema do tipo systemd-nspawn / LXC, para contêineres de serviço do tipo Docker / rkt, e até mesmo determinados tempos de execução de VM "leves".
O conceito de "serviço portátil", em última análise, não fornecerá um ambiente totalmente isolado para a carga útil, como os contêineres pretendem principalmente. Em vez disso, eles são desde o início serviços de sistema mais parecidos, podem ser controlados com as mesmas ferramentas, são expostos da mesma maneira em todas as infraestruturas e assim por diante. Sua principal diferença é que o uso de um diretório raiz diferente do resto do sistema. Portanto, a intenção não é executar código em um mundo diferente e isolado do host - como a maioria dos contêineres faria -, mas executá-lo no mesmo mundo, mas com controles de acesso mais rigorosos sobre o que o serviço pode ver e fazer.
Como um ponto de diferenciação: como os programas executados como "serviços portáteis" são praticamente serviços de sistema regulares, eles não serão executados como PID 1 (como o Docker faria), mas como processo normal. Um corolário disso é que eles não devem gerenciar nada em seu próprio ambiente (como a rede), pois o ambiente de execução é mais compartilhado com o resto do sistema.
O principal caso de uso de "serviços portáteis" é estender o sistema host com extensões encapsuladas, mas fornecer integração quase total com o resto do sistema, embora possivelmente restrito por botões de segurança efetivos. Esse foco inclui extensões do sistema, às vezes chamadas de "contêineres super privilegiados".
Observe que os serviços portáteis estão disponíveis apenas para serviços do sistema, não para serviços do usuário. ou seja, a funcionalidade não pode ser usada para o material que o bubblewrap / flatpak está focando.
Este recurso beta / preview do Portable Services fará parte da próxima versão 239 do systemd.
Fonte
Até a próxoima!!
Nenhum comentário:
Postar um comentário