Explorando a história e evolução dos contêineres
Agora que já entendemos o que são os contêineres, vamos explorar um pouco a história e a evolução dos contêineres. É importante compreender que a ideia dos contêineres não surgiu com o Docker, mas sim por volta dos anos 70. Naquela época, tínhamos os mainframes, que eram computadores extremamente grandes, ocupando quase uma sala inteira, e eram muito caros. Apenas empresas de grande porte, com maior capacidade financeira, podiam adquiri-los. Devido ao alto custo, esses computadores eram compartilhados, pois não era viável ter uma máquina para cada processo da empresa. Assim, já naquela época, havia a necessidade de isolar nossos processos para evitar que um usuário afetasse outro.
Surgiu então a grande questão: como podemos separar os ambientes usando a mesma máquina, o mesmo host? Por volta de 1979, surgiu o chroot, que veio junto com o lançamento do UNIX versão 7. O chroot é uma chamada ao sistema UNIX que altera o diretório raiz de um processo. Dessa forma, o processo acredita estar no diretório raiz, mas na verdade está em um diretório falso, um subdiretório do sistema real. Como podemos ver na imagem, temos um subdiretório raiz falso. Isso já era uma forma de isolamento, mas o chroot isolava apenas os sistemas de arquivos, ainda não havia uma tecnologia capaz de isolar redes, usuários ou a CPU da máquina. Podemos dizer que o chroot foi uma peça conceitual fundamental na história dos contêineres, sendo, por assim dizer, o precursor de tudo, um ancestral distante do que fazemos hoje com os contêineres.
Avançando para os anos 2000 com FreeBSD Jails e Linux VServer
Nos anos 2000, surgiram os FreeBSD Jails. Jails, em inglês, significa "jaula", e era um mecanismo de isolamento do sistema operacional FreeBSD. O FreeBSD derivou do UNIX e permitiu criar vários sistemas isolados, chamados jails, dentro do mesmo sistema operacional, compartilhando o mesmo kernel. Nessa etapa, já havia separação de processos, usuários, sistemas de arquivos e também de rede. Podemos dizer que os FreeBSD Jails são uma extensão do conceito de chroot, mas o FreeBSD não é Linux, é um sistema operacional próprio com seu próprio kernel, nativo desse sistema. Portanto, ainda estávamos falando de um ecossistema muito limitado ao mundo BSD.
Em 2001, surgiu o primeiro esforço no Linux para separar ambientes e aplicações. Surgiu o Linux VServer, que permitia ter vários ambientes isolados dentro do mesmo kernel Linux. Era o mesmo conceito dos FreeBSD Jails, mas agora aplicado ao kernel do Linux. Para usar o VServer, era necessário instalar um patch adicional no kernel Linux, exigindo um kernel modificado. Na prática, isso significava que a instalação e manutenção eram muito complexas, e era necessário entender bastante de Linux para usar o VServer. Não era algo simples; era preciso ter um domínio técnico elevado. Não tínhamos uma camada amigável como a que temos hoje com o Docker, por exemplo.
Introduzindo Solaris Zones e OpenVZ
Em 2004, surgiu o Solaris Zones, que foi extremamente importante para o desenvolvimento dos contêineres, pois compartilhava a mesma ideia conceitual dos anteriores: dividir o sistema Solaris, um sistema operacional da Oracle, em vários ambientes isolados, chamados de zones. Havia as Global Zones, que eram o sistema principal que rodava no host, e as Non-Global Zones, que eram os ambientes isolados em si, que podemos considerar como contêineres. Havia isolamento de sistema de arquivos, rede, processos e controle de recursos. O interessante do Solaris Zones, que foi muito popular na época, é que era muito fácil replicar ambientes, quase instantaneamente. Possuía uma tecnologia que, para a época, era impressionante, sendo amplamente utilizado. No entanto, o problema é que também estava restrito ao ecossistema Solaris, da Oracle, e Solaris é um sistema operacional da família UNIX, mas não é Linux.
Em 2005, finalmente surgiu uma solução que dividia o kernel Linux em vários ambientes isolados: o OpenVZ, que vem de Open Virtuozzo. A Virtuozzo é uma empresa de tecnologia que já trabalhava com isolamento e criou o Open Virtuozzo, que dividia o kernel Linux em ambientes isolados. O interessante é que essa ferramenta alcançou escala comercial, por meio das VPS, que eram servidores privados, Virtual Private Servers. O OpenVZ também surgiu como um patch do kernel, exigindo um kernel modificado, e era mais evoluído que o VServer, pois já possuía ferramentas de administração próprias, permitindo melhor controle de recursos e isolamento mais completo, especialmente a nível de rede.
Evoluindo com cgroups, namespaces e LXC
Entre 2006 e 2008, ocorreu uma mudança significativa com o surgimento dos cgroups (grupos de controle) e dos namespaces. Esses dois são mecanismos do kernel Linux, recursos nativos que possibilitaram a criação dos contêineres. Os control groups limitam os recursos da nossa máquina, como CPU, memória, leitura/escrita em disco e número de processos. Já os namespaces são uma divisão mais lógica, que isola processos, a rede, entre outras coisas.
Em 2008, surgiu o LXC, que significa Linux Containers (Contêineres Linux), possibilitando a criação de ambientes isolados dentro do Linux. Isso foi possível pela combinação de namespaces e cgroups. O LXC foi uma evolução prática dessas duas características do kernel Linux, fornecendo ferramentas para gerenciar contêineres e utilizar recursos nativos do kernel. Dessa forma, trabalhar com contêineres no Linux tornou-se menos complexo, pois não era necessário adicionar ou modificar o kernel para isso.
Popularizando contêineres com o Docker
Em 2013, surgiu o Docker. Inicialmente, o Docker utilizava o LXC como base. Pode-se questionar: se o Docker usava LXC e não havia diferença técnica, por que o Docker se destacou? O Docker se destacou e tornou-se extremamente popular por sua simplicidade. Ele não foi criado apenas pensando na tecnologia de isolamento, mas como uma plataforma para distribuir aplicações. Além do LXC, que era o conceito técnico de isolamento do kernel com cgroups e namespaces, o Docker trouxe a possibilidade de ter imagens versionadas e portáteis em camadas. Falaremos mais sobre as imagens posteriormente.
O Docker transformou os contêineres em uma unidade de entrega de software. Ele é extremamente simples de usar, com foco nas pessoas desenvolvedoras. Hoje, para executar contêineres, não é necessário ser um especialista em Linux. O foco passou do gerenciamento de infraestrutura para o desenvolvimento de software. As pessoas desenvolvedoras não precisam ser especialistas em Linux para criar um ambiente isolado. Além disso, o Docker criou um ecossistema e um registro central onde é possível compartilhar imagens, acelerando o desenvolvimento de software, padronizando o desenvolvimento e permitindo que as empresas entreguem seus produtos com mais velocidade e qualidade, aumentando a produtividade. Por isso, o Docker se tornou tão popular e famoso.
Estabelecendo padrões com OCI e orquestrando contêineres
Entre 2014 e 2015, o Docker evoluiu, como toda tecnologia, e criou sua própria biblioteca de execução chamada LibContainer, que posteriormente se tornou o que conhecemos hoje como runc. Isso significou que o Docker deixou de usar o LXC e criou sua própria biblioteca, resultando no padrão OCI.
A OCI, Open Container Initiative, é uma organização criada por empresas e pela comunidade de desenvolvimento para estabelecer um padrão na criação de contêineres e imagens. Isso evita a fragmentação no ecossistema de contêineres e permite a padronização. A OCI define como executamos um contêiner, como devem ser as configurações e os processos, além de especificar como as imagens devem ser construídas, qual é o formato de empacotamento e a distribuição dessas imagens.
Desde 2014, surgiram tecnologias focadas em orquestrar milhares de contêineres, devido à popularidade crescente dos contêineres. A questão passou a ser como gerenciar milhares deles. Nesse contexto, surgiu o Kubernetes, uma ferramenta para orquestrar, programar e escalar contêineres. Por isso, é extremamente popular e recomendada para aprofundamento.
Concluindo a evolução dos contêineres
Os contêineres deixaram de ser locais e se tornaram uma arquitetura totalmente distribuída. Hoje, temos contêineres em praticamente tudo. Serverless utiliza contêineres por trás, plataformas como serviço usam contêineres, e o isolamento em si se tornou uma commodity, sendo o padrão no desenvolvimento de software.
Concluindo esta aula, os contêineres não são uma novidade. O que mudou não foi a ideia original, que vem dos anos 70, mas a forma como os usamos e construímos. Continuamos evoluindo, e as tecnologias não param de avançar, especialmente hoje com a IA. Certamente, encontraremos formas de fazer mais com menos, otimizando e melhorando os processos continuamente.
Nos vemos na próxima aula.