[Este blog foi distribuído pelo site http://nitschinger.at/].
Motivação
Como trabalho como parte da equipe de engenharia da Couchbase, preciso executar meu código em várias implantações de servidor. Executamos uma grande variedade de sistemas operacionais e versões de software, assim como nossos clientes. Para corrigir bugs de forma confiável e criar novos recursos, é fundamental ter um cluster em funcionamento que se assemelhe o máximo possível a essas implementações. Sei que posso executar todas essas combinações no EC2, mas o custo para isso seria muito alto e, na maioria das vezes, é um exagero.
O que eu preciso é colocar esse cluster em funcionamento em minutos e não gastar muito tempo para configurá-lo. Ouvi falar de Vagrant e Marionete no passado, mas nunca cheguei a usá-los em minha própria caixa (embora eu sempre use VirtualBox no MacOS para criar máquinas virtuais manualmente).
Hoje de manhã, sentei para dar uma olhada mais de perto em como essas ferramentas podem me ajudar a ser mais produtivo e, para minha grande surpresa, consegui executar um cluster de 4 nós do Couchbase Server em menos de 30 minutos (com a pesquisa de todos os detalhes de configuração). Como é tão fácil, quero compartilhar isso com você.
Pré-requisitos
Antes de podermos provisionar nossos nós, você precisa ter certeza de que o Vagrant e o VirtualBox estão instalados. Se você usa o MacOS como eu, basta baixar o arquivo .dmg para ambos e está tudo pronto. Agora, crie um diretório em algum lugar para armazenar os arquivos de configuração - eu chamei o meu de "vagrants".
Nesse diretório, você precisa criar um arquivo Vagrantfile. É como os Vagrants arquivo de criação e ele o pegará para saber como você deseja que seus nós sejam provisionados. Observe que isso não configura o software no topo do sistema operacional (como a instalação do Couchbase), pois isso é tratado pelo puppet em uma etapa separada. Aqui está a configuração completa:
# Número de nós a serem provisionados
numNodes = 4
# Base de endereços IP para rede privada
ipAddrPrefix = "192.168.56.10"
# Definir o número de RAM para cada nó
config.vm.provider "virtualbox" do |v|
v.customize ["modifyvm", :id, "-memory", 1024]
final
# Provisione o próprio servidor com o puppet
config.vm.provision :puppet
# Faça o download da caixa inicial a partir desta url
config.vm.box_url = "http://files.vagrantup.com/precise64.box"
# Provision Config para cada um dos nós
1.upto(numNodes) do |num|
nodeName = ("node" + num.to_s).to_sym
config.vm.define nodeName do |node|
node.vm.box = "precise64"
node.vm.network :private_network, ip: ipAddrPrefix + num.to_s
node.vm.provider "virtualbox" do |v|
v.name = "Nó do servidor Couchbase " + num.to_s
final
final
final
final
Esse arquivo é apenas um código rubi que configura o Vagrant. Vamos examinar cada diretriz e ver o que ela faz por nós.
numNodes = 4
# Base de endereços IP para rede privada
ipAddrPrefix = "192.168.56.10"
Você pode alterar esses valores, eu apenas os criei para se adequarem ao meu ambiente aqui. Dependendo da quantidade de numNodes definido, as VMs serão criadas. Adicionei um loop abaixo, dependendo dessa configuração, para não ter que duplicar muito o código. O prefixo do endereço IP é usado para determinar facilmente o endereço IP (estático) do servidor. Os números serão contados para cima de forma incremental, de modo que você terá quatro servidores acessíveis por meio de 192.168.56.101 para 192.168.56.104.
config.vm.provider "virtualbox" do |v|
v.customize ["modifyvm", :id, "-memory", 1024]
final
Esse bloco de configuração é necessário para aumentar o tamanho da memória da VM. Por padrão, é menor do que isso (acredito que cerca de 512 MB), e eu quero ter 1 GB de RAM para cada uma. Obviamente, sinta-se à vontade para ajustar esse valor ou removê-lo completamente.
config.vm.provision :puppet
Como usaremos o puppet para provisionar o software do servidor, precisamos dizer ao Vagrant para usá-lo.
config.vm.box_url = "http://files.vagrantup.com/precise64.box"
O Vagrant reutiliza imagens predefinidas para que você não precise reinstalar tudo do zero. Aqui, usamos uma caixa predefinida do Ubuntu 12.04 de 64 bits.
1.upto(numNodes) do |num|
nodeName = ("node" + num.to_s).to_sym
config.vm.define nodeName do |node|
node.vm.box = "precise64"
node.vm.network :private_network, ip: ipAddrPrefix + num.to_s
node.vm.provider "virtualbox" do |v|
v.name = "Nó do servidor Couchbase " + num.to_s
final
final
final
Esse bloco de código configura cada máquina virtual. Dado o número de nós que queremos criar, para cada um deles ele atribui um endereço IP e dá a ele um nome descritivo dentro do Virtualbox. Se você quiser adicionar configurações dependentes do servidor, o bloco "node" (nó) é o lugar certo para isso. Caso contrário, ele escolherá as configurações de todo o cluster definidas no bloco "config".
Agora, se executarmos vagabundo para cima a partir da linha de comando nesse diretório, teríamos quatro máquinas Ubuntu configuradas nas quais poderíamos entrar por SSH, mas nada mais seria instalado. Para que eles façam alguma coisa, queremos instalar o Couchbase Server. O Puppet é um software de automação de sistemas e é muito bom para provisionar sistemas. O Vagrant tem um suporte incrível para ele, tudo o que precisamos fazer é criar um default.pp dentro de um arquivo manifestos que se parece com este:
comando => "/usr/bin/wget http://packages.couchbase.com/releases/2.0.1/couchbase-server-enterprise_x86_64_2.0.1.deb",
cwd => "/home/vagrant/",
cria => "/home/vagrant/couchbase-server-enterprise_x86_64_2.0.1.deb",
before => Package['couchbase-server']
}
exec { "install-deps":
comando => "/usr/bin/apt-get install libssl0.9.8",
before => Package['couchbase-server']
}
pacote {"couchbase-server":
provedor => dpkg,
garantir => instalado,
source => "/home/vagrant/couchbase-server-enterprise_x86_64_2.0.1.deb"
}
Vamos examinar os componentes internos mais uma vez.
comando => "/usr/bin/wget http://packages.couchbase.com/releases/2.0.1/couchbase-server-enterprise_x86_64_2.0.1.deb",
cwd => "/home/vagrant/",
cria => "/home/vagrant/couchbase-server-enterprise_x86_64_2.0.1.deb",
before => Package['couchbase-server']
}
No puppet, definimos algumas tarefas que queremos executar. Essa tarefa executa um comando shell wget e armazena o arquivo dentro do diretório inicial do usuário. Dizemos ao puppet para baixar o pacote debian do servidor. Observe que há um antes de para a tarefa de instalação do pacote, pois não é possível instalá-lo antes de o arquivo não ter sido baixado.
comando => "/usr/bin/apt-get install libssl0.9.8",
before => Package['couchbase-server']
}
Também precisamos instalar libssl0.9.8 no servidor, essa é a única dependência que ele tem. Usamos a ferramenta de linha de comando apt-get para isso.
provedor => dpkg,
garantir => instalado,
source => "/home/vagrant/couchbase-server-enterprise_x86_64_2.0.1.deb"
}
Por fim, podemos instalar o pacote debian do couchbase-server, porque o arquivo está no lugar e todas as dependências estão satisfeitas.
É claro que esse arquivo puppet é muito simples e eu sei que você pode fazer muito mais com ele (e talvez até simplificá-lo ainda mais), mas para as minhas necessidades ele é mais do que suficiente. Se eu quiser uma versão diferente do servidor, só preciso alterar o arquivo puppet e apontá-lo para o novo pacote debian.
Agora, se executarmos vagabundo para cima novamente, muito mais acontece. Observe que, se quiser brincar com seus arquivos de marionete, você também pode usar provisão para vagabundos para aplicar as alterações enquanto o nó estiver em execução.
Se tudo estiver correto, o resultado deverá ser semelhante a este:
Trazendo a máquina 'node2' para cima com o provedor 'virtualbox'...
Trazendo a máquina 'node3' para cima com o provedor 'virtualbox'...
Trazendo a máquina 'node4' para cima com o provedor 'virtualbox'...
[node1] Limpando todas as portas encaminhadas definidas anteriormente...
[node1] Criando metadados de pastas compartilhadas...
[node1] Limpando todas as interfaces de rede definidas anteriormente...
[node1] Preparando interfaces de rede com base na configuração...
[node1] Encaminhando portas...
[node1] - 22 => 2222 (adaptador 1)
[node1] Executando qualquer personalização de VM...
[node1] Inicializando a VM...
[node1] Aguardando a inicialização da VM. Isso pode levar alguns minutos.
[VM inicializada e pronta para uso!
[node1] Configurando e habilitando interfaces de rede...
[node1] Montagem de pastas compartilhadas...
[node1] - /vagrant
[node1] - /tmp/vagrant-puppet/manifests
[node1] Executando o provisionador: puppet...
Executando o Puppet com default.pp...
stdin: não é um tty
aviso: /Stage[main]//Exec[install-deps]/returns: executado com sucesso
aviso: Execução do catálogo concluída em 0,77 segundos
.... mais para todos os outros nós.
Em seguida, você pode direcionar seu navegador para 192.168.56.10[1-4] e trabalhar com seu cluster do Couchbase. Se tiver terminado, você poderá usar o vagrant halt para desligá-lo de forma limpa. Muito útil também é o vagrant suspenderque salvará o estado dos nós em vez de desligá-los completamente.
Se quiser interagir com um dos nós em vez de todo o cluster, você sempre poderá especificar o identificador do nó. Por exemplo, se quiser iniciar apenas o primeiro nó, você pode fazer isso com o comando vagrant up node1 comando.
Para mim, essa é uma maneira muito rápida e limpa de provisionar nós de servidor. Eu só preciso alterar algumas linhas em um arquivo e obter um novo cluster sem muito esforço. Ainda mais importante, posso colocar esses arquivos de configuração no controle de versão e compartilhe-os com outras pessoas!
Bom material. Fiz algumas alterações nos scripts do repositório. Como desabilitar timeouts durante o provisionamento no manifesto do puppet, mais estilo ruby no vagrantfile. Todos eles já estão integrados
Uau, isso funcionou tão facilmente. Menos de 10 minutos de trabalho da minha parte e tenho um cluster de 4 nós. Obrigado!
Olá, obrigado.
Funciona muito bem.
Dica para os usuários iniciantes (como eu) Os clusters do couchbase estão disponíveis no seu navegador em 192.168.56.10[1-4]:8091, o número da porta padrão após a instalação.