Conheça o framework Containerization

Olá! Meu nome é Michael. Hoje, tenho o prazer de apresentar um novo framework de código aberto. Containerization é um framework Swift para criação de apps conteinerizados que parecem nativos. Vamos explorar como o foco da Containerization em segurança, privacidade e desempenho ajudou a moldar seu design e a implementação de contêineres do Linux. Antes de abordar o framework Containerization, vamos aprender sobre contêineres. Depois, vamos examinar as APIs que a Containerization oferece. Por fim, vamos explorar uma ferramenta de linha de comando para criar, executar e gerenciar contêineres. Agora, vamos analisar o que é um contêiner e alguns casos de uso comuns que eles resolvem. Os contêineres do Linux se tornaram o padrão para como os apps no servidor são criados, testados e implantados. Ao implantar cargas de trabalho no servidor em grande escala, elas devem ser executadas em vários ambientes diferentes. Os contêineres permitem isolar essas cargas de trabalho da máquina host, bem como isolar as cargas umas das outras. Eles também permitem replicar os ambientes de implantação na máquina local. Com isso, podemos desenvolver e testar apps localmente, como se estivessem em produção. Os contêineres fazem isso permitindo que desenvolvedores integrem seus apps e as respectivas dependências. As dependências podem incluir binários, bibliotecas dinâmicas e ativos. Ter o app e as dependências integrados permite que os contêineres tenham versões diferentes dessas dependências da máquina host, além de outros contêineres. O resultado é integrado em uma única unidade implantável: um contêiner. Os contêineres também fornecem isolamento adicional de tempo de execução. Os contêineres geralmente têm uma pilha de rede isolada da máquina host. Para privacidade, os processos em execução em um contêiner não podem ver ou inspecionar processos em execução no host ou em outros contêineres. E os contêineres podem ser dimensionados independentemente uns dos outros. Recursos como CPU, memória e disco podem ser alocados com base nas necessidades da carga de trabalho.

Para executar um contêiner do Linux no macOS, precisamos virtualizar o ambiente Linux. A solução mais comum é gerar uma grande máquina virtual para hospedar todos os contêineres em execução. Os recursos são alocados para a máquina virtual e, conforme contêineres são adicionados, os recursos são divididos, onde necessário. Quando é preciso compartilhar outros diretórios e arquivos do Mac, eles são compartilhados com a máquina virtual e depois fornecidos ao contêiner específico que solicitou os dados. Ao procurar maneiras de trazer contêineres do Linux para o macOS, tínhamos alguns objetivos em mente. Por segurança, nosso objetivo é fornecer a cada contêiner o mesmo nível de isolamento das grandes máquinas virtuais. Também queremos reduzir a necessidade de utilitários básicos e bibliotecas dinâmicas nessas máquinas virtuais. Isso reduz a superfície de ataque e o custo de manutenção para mantê-las atualizadas. Por privacidade, a limitação do acesso de diretórios deve ser feita por contêiner. Somente o contêiner que solicita o diretório deve ter acesso a esse conteúdo. E queremos proporcionar uma experiência eficiente, respeitando os recursos do usuário.

Mantivemos esses objetivos de design em mente ao criar a Containerization. Containerization é um framework Swift de código aberto. Ela fornece APIs para gerenciar imagens, executar contêineres e um sistema de inicialização integrado no Swift. Vamos explorar algumas das APIs de como um contêiner é criado. Primeiro, veremos como a Containerization lida com o gerenciamento de imagens.

A maioria dos contêineres é criada a partir de uma imagem. Uma imagem é um artefato de distribuição com o conteúdo do sistema de arquivos e uma configuração padrão. As imagens funcionam como um modelo ao criar um contêiner.

A Containerization fornece APIs para obter o conteúdo e a configuração do sistema de arquivos da imagem. Essa operação consiste em solicitações para um registro, um serviço que lida com armazenamento e distribuição de imagens e grava a resposta do Registro no sistema de arquivos local para uso.

Com uma cópia local da imagem, a configuração dela pode ser usada como ponto de partida para um novo contêiner. A configuração da imagem pode conter o processo padrão a ser executado, o diretório de trabalho onde o processo é executado e qual usuário executar. O conteúdo do sistema de arquivos de uma imagem inclui os arquivos e diretórios para o app. Para um acesso eficiente ao conteúdo da imagem, expomos o sistema de arquivos como um dispositivo de bloqueio. Um dispositivo de bloqueio consiste em criar um arquivo grande e formatá-lo com um sistema de arquivos. Para que os contêineres Linux consumam esse dispositivo de bloqueio, ele deve ser formatado com um sistema de arquivos que o Linux entenda. O EXT4 é um sistema de arquivos do Linux popular, e a Containerization fornece um pacote do Swift para formatar, criar uma estrutura de diretórios e preencher um sistema de arquivos EXT4 diretamente do Swift. Após criar um contêiner a partir de uma imagem, uma máquina virtual Linux deve ser iniciada para executar o contêiner. Por segurança, nosso objetivo era fornecer o mesmo nível de isolamento usado pelas grandes máquinas virtuais e aplicá-lo a todo e qualquer contêiner iniciado. A Containerization faz isso executando cada contêiner dentro da própria máquina virtual leve enquanto fornece tempos de início abaixo de segundos. Isso também oferece o benefício de que cada contêiner tem o próprio endereço IP dedicado. O endereço IP dedicado fornece acesso de rede eficiente a cada contêiner e elimina a necessidade de mapear portas individuais para acessar os serviços fornecidos pelos contêineres. Ao compartilhar diretórios e arquivos, somente o contêiner que solicita o diretório tem acesso ao conteúdo. E recursos como CPU e memória. Se nenhum contêiner estiver em execução, nenhum recurso será alocado. Após iniciar, os próximos passos ocorrem na máquina virtual. Vamos ver como a Containerization configura o ambiente de tempo de execução antes de iniciar o contêiner. Após iniciar a máquina virtual, um processo inicial é gerado. O binário desse processo é fornecido por um sistema de arquivos mínimo que faz parte da Containerization. Esse sistema de arquivos contém um binário chamado vminitd. O vminitd é um sistema de inicialização criado no Swift e executado como o primeiro processo na máquina virtual.

A execução como processo inicial vem com muitas responsabilidades diferentes antes e durante a execução do contêiner. O vminitd atribui os endereços IP às interfaces de rede, montando sistemas de arquivos como o conteúdo da imagem que expomos com o dispositivo de bloqueio. Ele é responsável por iniciar e supervisionar todos os processos em execução na máquina virtual.

O vminitd tem uma API que permite gerar e gerenciar os processos a partir do host. Historicamente, ao usar uma grande máquina virtual, eles eram inicializados como um sistema completo. O sistema de arquivos dessas grandes máquinas virtuais inclui fatores como uma implementação libc, bibliotecas dinâmicas e utilitários principais, como cd, cp e ls. Por segurança, queremos reduzir a superfície de ataque dos contêineres. O sistema de arquivos fornecido pela Containerization não tem utilitários básicos. Ele não contém bibliotecas dinâmicas, nem implementação libc. Para que o vminitd seja executado nesse ambiente restrito onde não há bibliotecas para vincular, precisamos compilar o vminitd como um executável estático. Para isso, usamos o SDK Static Linux do Swift, que permite compilar binários estáticos do Linux, diretamente do Mac. Também podemos usar o musl, que é uma implementação libc com excelente suporte para ligação estática. Com isso, produzimos o vminitd como um executável Linux estático compilado pelo Mac e capaz de executar nesse ambiente isolado. A Containerization combina todos esses componentes principais, oferecendo uma API capaz de criar soluções para contêineres do Linux. Agora, vamos conhecer uma ferramenta de linha de comando para executar contêineres de forma simples e robusta. A ferramenta de contêiner consiste em uma CLI e serviços XPC criados com as APIs Containerization. Esses serviços dão suporte para armazenamento, gerenciamento de imagens e serviços de rede que alocam endereços IP para contêineres e resolvem solicitações DNS. E, por fim, o gerenciamento e o tempo de execução dos contêineres. Vamos acessar nosso terminal e usar o contêiner para puxar uma imagem para nossa máquina local. Agora que estamos no terminal, podemos digitar container image pull.

Agora, fornecemos um nome de imagem. Nessa demonstração, usaremos alpine:latest. Ao executar esse comando, o contêiner está puxando o conteúdo da imagem e a configuração no local antes de criar o arquivo de bloqueio para usarmos. Muito bom.

Agora que a imagem existe no local, vamos executar um contêiner com base nela.

A ferramenta criará um contêiner a partir do conteúdo e da configuração do sistema de arquivos da imagem. Em seguida, usará as APIs Containerization para iniciar uma máquina virtual leve para executar o contêiner. Vamos voltar ao terminal para ver isso em ação. Podemos iniciar o comando run digitando container run, e queremos executar um shell interativo. Assim, adicionaremos um dispositivo terminal com -t, uma entrada interativa com a bandeira -i. Por fim, fornecemos o nome da imagem e o comando a executar, que será um sh, um shell.

Após algumas centenas de milissegundos, acessamos um shell interativo. Podemos inspecionar o ambiente de tempo de execução do contêiner executando uname-a, que mostra que estamos em um ambiente Linux. E, por causa do isolamento dos contêineres, quando executamos comandos como ps aux, vemos apenas nosso shell e o processo ps. Nenhum outro processo em execução no host ou outros contêineres é visível. Essa é a ferramenta de linha de comando de contêiner disponível no GitHub para você conferir. Com as APIs Containerization, ela é capaz de oferecer uma experiência segura, privada e de desempenho para contêineres. Convidamos você a participar conforme trazemos primitivas da Containerization para macOS. Se você quer criar um projeto que integre contêineres Linux, confira o framework Containerization no GitHub. Veja o código-fonte para saber como máquinas virtuais leves são iniciadas. Explore todos os pacotes do Swift multiplataforma criados para o vminitd. E confira os projetos de exemplo. Se você quiser começar a executar contêineres, experimente a ferramenta de contêiner e participe da conversa no GitHub. Você pode ver o código-fonte, enviar problemas e criar solicitações pull. Mal podemos esperar para saber o que você criará.