O documento discute o que são containers Linux, comparando-os com máquinas virtuais. Explica que containers isolam processos dentro do mesmo sistema operacional usando namespaces e cgroups. Containers compartilham o kernel do sistema anfitrião e oferecem maior portabilidade e desempenho do que máquinas virtuais.

1. Linux Containers
do que são feitos? de onde vem? quem os alimenta?

2. Quem sou eu
Marcos Paulo de Souza
● Contribuidor de alguns projetos como bubblewrap, LXC, Linux Kernel, entre outros
● Usuário Linux a mais de oito anos
@omarcosouza
marcos.souza.org@gmail.com

3. Agenda
● O que são containers
● Containers vs. Máquinas Virtuais
● O que compõe um container
● Por dentro dos containers:
○ Kernel
○ Userspace
○ Segurança
● Diferenças entre container runtimes
● Rootless containers
● Referências

4. O que são containers?
Um container Linux®
é um conjunto de processos que são isolados do resto do sistema. Esses
processos são executados a partir de uma imagem distinta que fornece todos os arquivos
necessários a eles. Por fornecer uma imagem que contém todas as dependências de um
aplicativo, o container é portátil e consistente durante todas as etapas desde o
desenvolvimento, teste e, por fim, produção.
Referência: https://www.redhat.com/pt-br/topics/containers/whats-a-linux-container

5. O que são containers?
● Em termos simples, um container permite que uma aplicação ou ambiente sejam executados
exatamente da forma em diferentes máquinas
● Em alguns aspectos, containers se parecem muito com máquinas virtuais
○ Mas em outros, são bem diferentes...

6. Containers vs. Máquinas Virtuais
● Segurança:
○ Máquinas Virtuais tem maior segurança sobre containers, pois rodam sobre a camada do hypervisor
○ Containers são isolados dentro do mesmo OS, e não são “tão” isolados assim...
Referência: https://www.serverpronto.com/spu/2016/05/containers-vs-virtual-machines-vms-is-there-a-clear-winner/

7. Containers vs. Máquinas Virtuais
● Performance
○ Um container é basicamente um processo comum dentro do sistema operacional
○ Uma máquina virtual executa todo um novo sistema operacional, com emulação de hardware, novo kernel,
interrupções, e tudo mais o que um sistema operacional precisa executar, gastando assim mais recursos do
sistema HOST
Referência: https://www.serverpronto.com/spu/2016/05/containers-vs-virtual-machines-vms-is-there-a-clear-winner/

8. Containers vs. Máquinas Virtuais
● Sistema Operacional:
○ Máquinas Virtuais conseguem executar diferentes sistemas operacionais não
■ Um HOST Linux consegue criar uma máquina virtual Windows
○ Containers estão restritos a executarem um mesmo sistema operacional do seu HOST.
■ Um container sendo executado em um HOST Linux consegue executar somente container Linux, por
exemplo uma distribuição diferente da executada pelo HOST
■ Containers compartilham o mesmo kernel do sistema host

9. O que compõe um container?
● rootfs/imagem de um sistema
○ Sistema de arquivos onde será executado o container
● Namespaces
○ Isola o processo do restante do sistema
● Cgroups
○ limita os recursos do processo do container, memória, disco
● Interfaces VETH
○ permitir o container acessar a rede quando estiver utilizando um network namespace
● Union FS
○ Para montar a imagem em camadas RO e RW
● SELinux/AppArmor
● Seccomp
● ...

10. O que compõe um container?
● Se você está rodando uma distribuição Linux com um kernel recente, você já está executando um
container:
○ Execute lsns na sua máquina
● O processo init (systemd), já cria um namespace que será pai de todos os outros criados depois
○ Porém este “container” criado pelo sistema não tem restrições, funcionando somente como ponto de partida
para uso de cgroups e outros namespaces para os processos a serem criados

11. O que compõe um container?

12. Por dentro dos containers: Kernel
● Não existe o conceito de container no kernel Linux

13. Por dentro dos containers: Kernel
● Não existe o conceito de container no kernel Linux
○ Existem namespaces!
○ Namespaces são :
■ PID
■ UTS
■ MOUNT
■ IPC
■ CGROUP
■ NET
■ USER

14. Por dentro dos containers: Kernel
● PID
○ Isola o processo dos demais processos do sistema. Dentro do docker por exemplo, você somente verá o seu
próprio process. Ao criar um novo PID namespace, o PID do primeiro processo dentro do namespace é 1.
● UTS
○ Permite ao container ter um hostname diferente do SO que executa o container.
● MOUNT
○ Isola o processo da tabela de mounts do SO. Por exemplo, se o SO tiver montado um pendrive em
/run/USER/pendrive, este não será visto de dentro deste namespace.
● IPC
○ Dentro deste namespace o processo não conseguirá enxergar formas de IPC do SystemV, como Shared
Memory, Semaphores e outros.

15. Por dentro dos containers: Kernel
● CGROUPS
○ Este namespace isola os cgroups do processo em relação às estruturas do HOST
● NET
○ Isola os recursos de rede do processo. Em recursos de rede podemos destacar as tabelas de roteamento,
interfaces de rede, regras de firewall, portas em uso entre outros
● USER
○ Permite ao processo mapear um usuário diferente dentro do namespace. “Root dentro do container, porém fora
do container o mesmo processo tem um UID 1000 por exemplo”

16. Por dentro dos containers: Kernel
● Todos os namespaces precisam ser executados por um usuário com privilégios, menos o USER
namespace
○ Neste caso, é possível criar um novo USER namespace, e criar todos os outros namespaces
● Graças ao USER namespace, é possível criar um container sendo um usuário comum

17. Por dentro dos containers: Userspace
● Como criar um novo namespace:
○ unshare : Cria novo namespace para o processo corrente
○ clone: Faz um “fork” criando novos namespaces para o processo recém criado
○ setns: Permite associar o processo corrente a um namespace diferente

18. Por dentro dos containers: Userspace
● DEMO

19. Por dentro dos containers: Segurança
● Existem vários mecanismo para assegurar que um processo não “escape” do container
● LSM (Linux Secure Modules)
○ SELinux, AppArmor, TOMOYO, Smack
○ MAC (Mandatory Access Control) vs DAC (Discretionary Access Control)
● Seccomp
○ Filtra system calls
○ Evita que o container faça coisas “estranhas” , como um umount
● Não executar um container “privilegiado”
● Execução de containers dentro de uma VM (Kata Containers)
● Auditar imagens de containers antes de instalar (dockerhub)
● USER namespaces
○ Se o processo conseguir “escapar” do container, ele terá o UID de um processo comum no HOST

20. Diferenças entre container runtimes
● LXC (Linux Containers)
○ Criado em 2008
○ Feito em C
○ Conceito de Machine Container
■ Dentro do container, mais de um processo é executado
■ systemd, sshd, ...
○ Pode criar containers com usuário comum (rootless)
■ Utiliza binários com setuid para criar VETH
● LXD
○ Feito em Go
○ Daemon REST, tipo o Docker daemon
○ Utiliza o LXC para manipular os containers

21. Diferenças entre container runtimes
● Flatpak
○ Criado em 2017
○ Feito em C
○ Focado em executar aplicações de forma segura em desktops
■ Utiliza o bubblewrap para o low-level
○ Conceito de Application Container
■ Um processo por container

22. Diferenças entre container runtimes
● Podman
○ Criado em 2018
○ Feito em Go
○ Conceito de Application Container
■ Um processo por container
○ Um substituto para o docker
■ Sem o daemon executando como root

23. Diferenças entre container runtimes
● Kata Containers
○ Criado em 2018
○ Feito em Go
○ Nao e um um container runtime, mas uma Lightweight VM
○ Integrado ao Kubernetes, executa container dentro de uma VM utilizando KVM

24. Diferenças entre container runtimes
● gVisor
○ Lançado em 2018
○ Feito em Go
○ Utiliza um kernel em userspace para interceptar as syscalls do container
■ Pode ocasionar lentidão se a aplicação faz muitas syscalls
○ Atualmente implementa em torno de 200 syscalls
■ Kernel Linux tem mais de 400 syscalls
○ Integrado ao Docker

25. Rootless Containers
● Conceito que permite executar containers sem precisar ser root
● Implica em utilizar USER namespace
○ Runc já tem suporte
● Alguns desafios para ter o rootless ser uma realidade:
○ Networking: Criação de VETH
■ Parcialmente resolvido com binários + setuid
○ Union FS
■ WIP com suporte a fuse (commitado no dia 06/06/2018)
○ Syscalls (setuid, setgroups, ...)
■ Parcialmente resolido utilizando ptrace
○ ...

26. Dúvidas

27. Referências
● https://rootlesscontaine.rs/
● Cgroups, namespaces, and beyond: what are containers made from?
https://www.youtube.com/watch?v=sK5i-N34im8&feature=youtu.be
● Keynote: Containers aka crazy user space fun
https://www.youtube.com/watch?v=7mzbIOtcIaQ&t=
● Container security: Do containers actually contain? Should you care? - 2015 Red Hat Summit
https://www.youtube.com/watch?v=a9lE9Urr6AQ&t=
● https://linuxcontainers.org/
● https://www.redhat.com/en/topics/containers
● https://github.com/google/gvisor/blob/master/README.md
● http://man7.org/linux/man-pages/man7/namespaces.7.html
● https://www.nccgroup.trust/us/our-research/understanding-and-hardening-linux-containers

28. Obrigado!
@omarcosouza
marcos.souza.org@gmail.com