Usando o LXC- Introdução

O LXC (Linux Containers) é uma ferramenta responsável em criar e gerenciar containers em ambiente linux. Os containers são abstrações virtuais de uma técnica de virtualização conhecida como virtualização a nível de sistema operacional.

Se você quiser saber mais sobre containers recomendo acessar meu artigo onde explico sobre virtualização.

Uma observação interessante a ser realizada é que containers só poderão ser executados em ambientes cujo kernel foi adaptado. Apenas o linux possui funções que permite manipular e gerir os containers até o momento. O projeto LXC é formado por diversos projetos pequenos (LXD, cgmanager, liblxc) que oferecem flexibilidade e um pequeno ecosistema que engloba diversas funcionalidades interessantes.

O LXC é desenvolvido em C, porém possui bindings para outras linguagens como Python (versões 2.7 e 3), Lua, Ruby e Haskell e atualmente recebe suporte da equipe da Canonical (sim, a mesma que é responsável pelo desenvolvimento do Ubuntu). Antes de adentrarmos nos detalhes da instalação vamos estudar um pouco mais sobre a história dos containers e quais são as features que eles necessitam hoje em dia para executar.

Introdução aos containers

As primeiras implementações de ambientes isolados aconteceram na década de 80 com o uso de chroot. Ele permitia o usuário criar e utilizar um diretório raiz diferente da máquina real. Naquela época a visibilidade para essa tecnologia era apenas para dar suporte à máquinas.

Com o passar dos anos, algumas empresas investiram essa idéia em tecnologias com uso diferente daquelas definidas no início. O FreeBSD desenvolveu o FreeBSD jail que permitia criar sistemas minimalistas, conhecidos como jails, do sistema que estava sobre execução. Isso permitia usuários instalarem programas sem comprometer o sistema real. Porém a segurança oferecida pelos jails não era satisfatória, o que tornou seu uso limitado a pequenos cenários (sem muita utilidade prática)

Outras tecnologias como Solaris Zones e HP-UX Zones apareceram para melhorar aspectos do FreeBSD jail, porém não conseguiram obter no mercado uma grande força. A partir daí surgiu duas grandes implementações que expandiram o uso dos containers para algo próximo do que conheçemos hoje, o Linux-Vserver e o OpenVZ.

O Linux-VServer surgiu com a idéia de utilizar containers da mesma maneira que utilizamos as máquinas virtuais, permitindo que as instâncias tivessem um nível de isolação e controle diferente das antigas tentativas de implementação. Porém o projeto Linux-VServer passou algum tempo sem atualizações e correções de alguns problemas que os containers possuíam (como isolação de recursos de memória, acesso a drivers físicos, etc) e isso fez enfraquecer seu uso diante a comunidade.

O OpenVZ apareceu apontando o uso de containers como uma tecnologia que se tornaria tendência nos ambientes servidores. O projeto que é desenvolvido pela Parallels trouxe muitas implementações para corrigir problemas e extender o uso dos containers.

Um grande problema que existia era o controle de recursos físicos dos containers. Através da implementação de Beancouters eles passaram a ser realizados de maneira mais fácil, porém não totalmente seguras e sem um alto nível de isolação.

O maior problema que o OpenVZ enfrenta é que suas atualizações para realizar determinadas atividades precisam ser implementadas a nível de kernel e muitas vezes os mantedores não estão interessados em inserí-lo no kernel oficial, ou temem que exista uma perda de performance dos demais componentes. Dessa maneira, o OpenVZ modifica uma determinada versão do kernel oficial e junta com sua ferramenta. O principal ponto ruim é que muitas vezes o kernel do OpenVZ não acompanha as novidades que são lançadas no kernel oficial, ficando para trás.

Alguns conceitos foram implementados no kernel e é oferecido como solução principal para oferecer algumas features de controle e isolamento de recursos de processos que são aproveitados pelos containers. As principais implementações são o namespace, para oferecer isolamento, e o cgroups, para oferecer controle (em um outro post irei explicar com mais detalhes essas duas implementações que são bastante importante para o uso de containers). O OpenVZ decidiu migrar o seu código para utilizar essas implementações que são padrões desde a versão 3.11 do kernel. A atividade de migração ainda não foi concluída.

O LXC é uma implementação que utiliza o cgroups e namespaces para oferecer isolação e controle de maneira padrão.

Instalando o LXC

Como não deixaria de ser, a canonical oferece na maioria das versões do Ubuntu o pacote nos repositórios oficiais da mesma. Dessa maneira sua instalação pode ser realizada de maneira simples, através do comando abaixo.

$ sudo apt-get install lxc

Caso seu sistema não possua o LXC nos repositórios, os mesmos podem ser instalados a partir da adição do seu PPA. Para adicionar o PPA e instalar o LXC utilize os comandos abaixo:

$ sudo add-apt-repository ppa:ubuntu-lxc/lxc-stable
$ sudo apt-get update
$ sudo apt-get install lxc

Após a conclusão da instalação devemos verificar se todas as features disponíveis podem ser utilizadas pelo LXC através do comando:

$ sudo lxc-checkconfig

A saída do comando é apresentada na figura abaixo:

Figura 1: Saída do comando lxc-checkconfig

Se a saída do comando apresentar que tudo está ativo (enabled), o kernel possui os suportes necessários para executar todas as features que o LXC necessita. Podemos observar que o cgroups está ativo e pode controlar recursos como memória, processamento, dispositivos, etc. Podemos observar também que o namespace está ativo e pode isolar usuários, processos, rede, etc. Se alguma dessas opções não se mostrarem ativas, o LXC funcionará limitado. Uma solução é atualizar o kernel do linux para a versão mais atual.

Criando o primeiro container

O LXC oferece uma série de ferramentas que permite o usuário criar e controlar de maneira fácil todos os aspectos de um container. O comando abaixo apresenta a criação de um container:

$ sudo lxc-create -t ubuntu -n ubuntulxc

Onde:

• -t ubuntu: template padrão
• -n ubuntulxc: nome do container

O template é a base do nosso container, ou seja, o sistema que será executado em nosso container. Vale a pena resaltar que o template não precisa ser igual ao sistema hospedeiro. O template executa um script que baixa todos os pacotes necessários e configura o ambiente necessário. Atualmente, podemos criar containers com  17 templates diferentes. O diretório /usr/share/lxc/template/ lista todos os templates disponíveis.

Para obter informações dos containers que foram criados, utilizamos o comando abaixo:

$ sudo lxc-ls -f
NAME        STATE  IPV4 IPV6 GROUPS AUTOSTART 
--------------------------------------------------
ubuntulxc2  STOPPED -    -     -       NO

O comando a seguir apresenta o status atual do container além de outras informações.

Iniciando um container

O comando abaixo inicia o container criado acima:

$ sudo lxc-start -n ubuntulxc

Vale ressaltar que o container quando criado ocupa o tty atual, liberando apenas quando desligado. Quando criamos um container o usuário padrão é configurado como ubuntu e a sua senha é ubuntu.

Desativando um container

Após utilizar o container, o próximo procedimento é desativá-lo. Esse processo é similar a desligar uma máquina virtual. Para isso, vamos abrir um novo terminal (já que ao iniciar um container o tty atual é utilizado para fornecer acesso ao container) e verificar o seu estado.

$ sudo lxc-ls -f
NAME        STATE  IPV4        IPV6 GROUPS AUTOSTART 
----------------------------------------------------
ubuntulxc2  RUNNING 10.0.3.53   -     -       NO

Percebemos que o estado atual do container é running (em execução) e possui um endereço IP atribuído pela bridge lxcbr0 que é criada quando instalamos o LXC (nos próximos posts irei mostrar como modificar o acesso do container a outros dispositivos).

Para desativar um container, basta executar o comando:

$ sudo lxc-stop -n ubuntulxc

Destruindo um container

Devemos destruir um container quando não desejamos mais utilizá-lo. Esse procedimento permite liberar o espaço em disco ocupado pelo container, similar a exclusão de uma máquina virtual. O comando abaixo permite destruir  o container ubuntulxc:

$ sudo lxc-destroy -n ubuntulxc

É necessário que o container esteja no estado de stopped para que tudo ocorra corretamente.

Executando um container temporário

Caso você esteja apenas interessado no resultado de um determinado comando ou um script em um container e não deseje manter o container em seu sistema, você pode criar um container temporário. Esse container utiliza como template o sistema atual e permite criar, executar e excluir o container de maneira automática. Essa opção é interessante quando não queremos passar por todo o procedimento acima apenas para obter um status de um comando.

Para executar um container temporário, utilizamos o comando abaixo:

$ sudo lxc-execute -n ubuntutemp -- sleep 5

Onde:

• — sleep 5: comando ou conjunto de comandos que serão executados no container. Nesse caso o comando sleep é executado, esperado por 5 segundos o container terminar.

Podemos verificar o estado desse container temporário da mesma maneira como vimos anteriormente. Após o comando (ou conjunto de comandos) terminarem de executar, o container é destruído.

Conclusão

Nesse post podemos conhecer um pouco mais sobre os containers e principalmente como instalar o LXC. Nos próximos posts irei mostrar como podemos configurar os containers criados a fim de utilizarmos conscientemente os recursos de hardware. Dúvidas, sugestões e críticas são sempre bem vindas. Keep Learning!

Referências

[1] http://pt.slideshare.net/LusEduardo3/lxc-introduction

[2] https://linuxcontainers.org/lxc/getting-started/

[3] https://en.wikipedia.org/wiki/Operating-system-level_virtualization

[4] http://linux-vserver.org/Welcome_to_Linux-VServer.org