O primeiro passo é reconfigurar o Chef Server. Precisaremos fazer isto pois o endereço IP público do servidor é alterado quando reiniciamos o mesmo. É importante notar que isto ocorre pois quando realizamos a criação do servidor não especificamos o uso de um endereço IP público fixo.
Após iniciar o servidor através da console da AWS, vamos executar os seguintes comandos:
$ sudo bash
# echo api_fqdn "\""$(curl --silent --show-error --url http://169.254.169.254/latest/meta-data/public-ipv4)"\"" > /etc/opscode/chef-server.rb
# chef-server-ctl reconfigure
# chef-manage-ctl reconfigure
No último lab, utilizamos um container para simular o registro de um Node
no Chef Server. Como o container em questão não existe mais (pois desligamos o servidor onde o mesmo está em execução), devemos excluir o Node através da interface web do Chef Server.
Para isto, em Nodes
, vamos selecionar o node first_container
e no campo actions, no canto direito da página, clicar em Delete
, conforme a imagem a seguir:
Agora que já temos nosso node deletado, precisamos baixar o Starter Kit novamente para reconfigurar nosso workspace. Neste caso, em nosso Chef Server, vamos clicar em Administration
na parte superior da tela, em seguida devemos clicar em Starter Kit
e então em Download Starter Kit
:
Feito isto, devemos enviar nosso novo Starter Kit para o Chef Server.
Podemos fazer isto utilizando o Amazon S3
ou algum client SCP, como o Filezilla, por exemplo.
Vamos agora excluir o diretório chef-repo
que existia em nosso servidor. Este diretório será substituído pelo novo arquivo gerado.
Para isto, vamos utilizar o comando:
# rm -rf chef-repo/
Em seguida, devemos extrair o conteúdo do novo Starter Kit. Vamos utilizar o comando:
# unzip unzip chef-starter.zip
Agora, devemos acessar o diretório chef-repo
e baixar os certificados ssl. Vamos utilizar os comandos:
# cd chef-repo
# knife ssl fetch
Para validar o funcionamento de nosso workspace, vamos utilizar o comando:
# knife client list
Agora vamos iniciar novamente nossa instância chef-server. Após iniciar nossa instância e acessar a mesma via SSH vamos executar um novo container, afim de simular um servidor.
Antes de termos um novo container em execução, no entanto, vamos remover o container anterior, que está com o status Exited
, utilizando os seguintes comandos:
$ sudo bash
# docker rm -f $(docker ps -a -q)
Vamos validar se o nosso ambiente está sem nenhum container em execução através do seguinte comando:
# docker ps
Note que não existe nenhum container em execução.
Vamos agora, executar um novo container, agora chamado motd_server
executando o comando:
# docker run -d -P --name motd_server ssh_container
Verifique o status de seu container através do comando:
# docker ps
A saída deverá ser semelhante a:
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
580fe1c98903 ssh_container "/usr/sbin/sshd -D" 2 seconds ago Up 1 second 0.0.0.0:32768->22/tcp motd_server
Ainda no Chef Client
, obtenha os dados para bootstrap de seu novo node. O primeiro passo é obter o endereço IP de sua instância. Faça isso através do comando:
# curl --silent --show-error --url http://169.254.169.254/latest/meta-data/local-ipv4; echo
Tome nota deste endereço IP, pois o mesmo será utilizado para o bootstrap de nosso novo Node. Agora, devemos obter a porta sendo mapeada em nossa instância para o acesso via ssh ao container em execução. Para isto, execute o comando:
# docker port motd_server 22 | awk '{split($0,a,":"); print a[2]}'
Anote também a porta utilizada por este container.
Vamos agora acessar o Chef Server
e utilizando o knife realizar o bootstrap de nosso novo node.
Ao acessar o Chef Server, acesse o diretório chef-repo
. Você pode verificar se já se encontra no diretório correto através do comando:
# pwd
Caso não esteja no diretório, acesse o mesmo utilizando o comando:
# cd chef-repo
Vamos agora utilizar o knife para realizar o bootstrap de nosso novo container. Para isto, devemos utilizar o comando:
# knife bootstrap `<endereço_IP_do_chef_client>`:`<porta_do_container>` -x root -P 123456 -N motd_server
Feito isto, vamos validar o bootstrap de nosso novo container primeiro em nossa interface web. Acesse novamente o Chef Server através da Web, e note que deverá existir um novo Node com o nome motd_server
:
Podemos também listar o nosso node através do comando:
# knife client list
O node motd_server
deverá ser listado em sua linha de comando.
Como já temos nosso ambiente funcional e com um node já registrado, vamos agora criar um novo cookbook para execução através do Chef Server.
Para isto, vamos utilizar o seguinte comando:
# chef generate cookbook cookbooks/motd
Gaste algum tempo para analizar a saída deste comando.
Após entender o que foi feito, vamos editar a nossa receita. Para isto, o primeiro passo é acessar o diretório cookbooks
em nosso chef-repo. Utilize o comando:
# cd cookbooks/motd
Explore o conteúdo deste diretório, afim de entender como funciona a estrutura padrão dos cookbooks do chef. Você pode inclusive explorar o conteúdo dos arquivos utilizando o comando cat
.
Mais informações sobre a estrutura dos cookbooks podem ser encontrados neste link.
Vamos editar nosso cookbook para que possamos executar algo em nosso novo node. Neste caso, vamos criar uma receita simples, que cria um arquivo chamado motd.txt
no diretório /tmp
de nosso container.
Para isto, edite o conteúdo do arquivo recipes/default.rb
e insira o seguinte:
file '/tmp/motd.txt' do
content 'Arquivo criado utilizando o Chef Server!'
end
Após realizar a edição, salve o arquivo.
Como vimos anteriormente, todas as receitas são disponibilizadas em nossos nodes através do Chef Server. Sendo assim, devemos enviar a receita recém criada para o servidor. Para isto, vamos executar os seguintes comandos:
# knife upload cookbooks/motd
NOTE: Este arquivo deverá ser executado a partir do diretório
chef-repo
.
Após realizar o upload de seu cookbook, você poderá verificar o conteúdo do mesmo através da interface web, clicando em Policy
na parte superior da tela, clidando em seu cookbook, chamado motd
e em seguida, na parte inferior da tela, selecionando Recipes
e em seguida default.rb
, conforme a imagem abaixo:
Você também conseguirá listar os cookbooks presentes no servidor através do seguinte comando:
# knife cookbook list
Como nosso cookbook já está presente em nosso servidor, o próximo passo é editar o Run list
para que o Chef Client instalado em nosso container possa realizar o download e a execução de nossa receita.
Para isto, na interface web do servidor, vamos clicar em Nodes
na parte superior da tela, selecionar o nosso node chamado motd_server
e clicar no campo Edit Run List
em actions:
Em seguida, devemos arrastar a receita motd
presente em Available Recipes
para o campo Current Run List
:
Em seguida, vamos clicar em Save Run List
.
Você pode validar a nova Run List de seu node através do comando:
# knife node show motd_server
Verifique se a receita motd
está sendo exibida.
O próximo passo para isto, é executar a nossa Run List no node motd_server
para que a receita motd
possa criar o arquivo no diretório /tmp
.
Vamos então acessar o nosso Chef Client
e executar o seguinte comando:
# docker exec -ti motd_server /bin/bash
NOTE: Este comando irá nos mover para dentro do container
motd_server
que está simulando um servidor em nosso ambiente. A partir daí, todos os comandos são executados dentro do container, e não no Chef Client.
Vamos agora utilizar o chef-client que foi instalado em nosso container durante o processo de bootstrap. Para isto, utilizamos o comando:
# chef-client
Note que o chef-client
irá realizar o download de seu cookbook e executar os passos localmente.
Agora, na interface web do Chef Server, clique em Reports
na parte superior da tela, e verifique o status de suas execuções:
Vamos criar um novo Node para que possamos simular a instalação do Apache. Para isto, vamos precisar gerar um novo container, expondo além da porta 22 para o ssh, também a porta 80 para o nosso web server.
Para isto, vamos voltar à nossa instância Chef Client
e editar o nosso Dockerfile
. Vamos editar a linha que contém a intrução EXPOSE
adicionando também a porta 80
. Esta linha deverá ficar da seguinte forma:
EXPOSE 22 80
Agora, vamos gerar uma nova imagem a partir de nosso Dockerfile. Esta imagem irá se chamar ssh_apache_image
. Para isto, utilizaremos o seguinte comando:
# docker build -t ssh_apache_image .
Após a geração desta imagem, vamos executar um novo container, expondo também a porta 80. Utilize o comando:
# docker run -d -p 80:80 -P --name apache_server ssh_apache_image
Vamos agora listar as portas utilizadas em nosso novo container utilizando o comando:
# docker port apache_server 22 | awk '{split($0,a,":"); print a[2]}'
Novamente, anote a porta apresentada para que possamos utilizar no processo de bootstrap.
Após a criação de uma nova imagem e a execução do container, realize o bootstrap deste novo node através do knife, em seu Chef Server. Execute os mesmos passos descritos no passo 7.
Agora, ainda em seu Chef Server, realize a criação de um novo Cookbook, desta vez chamado apache
. Utilize o comando:
# chef generate cookbook cookbooks/apache
Edite o arquivo cookbooks/apache/recipes/default.rb
e insira o seguinte conteúdo:
package 'apache2' do
action :install
end
service 'apache2' do
action [:enable,:start]
supports :reload => true
end
Note que agora, além de instalar o apache, estamos utilizando a receita também para habilitar e iniciar o serviço apache2
.
Envie seu novo cookbook para o servidor através do comando:
# knife upload cookbooks/apache
Siga o mesmo procedimento descrito no passo 11, porém desta vez para o novo node utilizando a receita apache
:
Em sua instância Chef Client
, execute o seguinte comando para ter acesso ao container onde será instalado o Apache:
# docker exec -ti apache_server /bin/bash
E em seguida, já dentro do container, execute o comando:
# chef-client
Note que o Apache será instalado.
A primeira maneira para validar o funcionamento do Apache em nosso novo node, é verificando se o serviço foi devidamente instalado e está ativo. Faça isto através do comando:
# service apache2 status
A saída deste comando deverá ser:
\* apache2 is running
Como estamos realizando a instalação de um servidor web, nada melhor do que utilizarmos o nosso browser para validação do funcionamento. Desta maneira, o primeiro passo é a liberação das regras do Security Group
para que possamos ter acesso à porta utilizada pelo container.
Para isto, vamos abrir a console da AWS e lá, acessar o serviço EC2
, clicar em Security Groups
no menu lateral esquerdo e selecionar o Security Group chef-client
criado anteriormente:
Clique então na aba Inbound
e então em Edit
. Na próxima tela, clique em Add Rule
e adicione uma regra com as seguintes informações:
- Type: Custom HTTP
- Source: Anywhere
E em seguida clique em Save
:
Agora, obtenha o hostname de sua instância chamada Chef Client
e acesse o mesmo utilizando seu Browser. Você deverá se deparar com a interface do Apache Server.