Usando Chef-solo para configurar um aplicativo Django no Ubuntu

• Criando o livro de receitas
• Etapas finais

Existem várias maneiras de automatizar o processo de instalação e configuração de uma caixa. Por qualquer motivo, se todo o nosso sistema neste momento compreender apenas uma única caixa, a configuração de uma infraestrutura completa do SCM (Software Configuration Management) será um exagero. Os scripts de shell são uma opção, mas também podemos usar uma versão simplificada do SCM, disponível em algumas das ferramentas disponíveis. Chef é uma das opções populares e "chef-solo" é o modo de configuração independente do Chef, onde não precisamos de um nó extra para atuar como um "servidor-chef". Tudo o que precisa é de um URL ou caminho para um pacote de tarball que contém livros de receitas do chef. Comparado aos scripts de shell, esse tipo de abordagem é mais declarativo e eficiente e também é uma boa introdução para começar com os processos de SCMs ou IaC (Infraestrutura como Código).

Alguns outros benefícios do uso do chef-solo:

• Composição: Use os livros de receitas da comunidade do supermercado chefe ou de outros lugares.
• Fonte livre e aberta; licenciado sob a permissiva licença Apache 2.0.
• Acesso ao restante do ecossistema do Chef (InSpec, ChefSpec, Cookstyle, Foodcritic, chef-shell etc)
• Os livros de receitas e receitas podem ser posteriormente adaptados ao modo cliente / servidor.

E algumas desvantagens:

• Alguns livros de receitas da comunidade no supermercado Chef estão desatualizados, quebrados e não são mantidos.
• chef-solo não pode resolver dependências por conta própria.

As 'receitas' dentro do 'livro de receitas' de um chef têm uma DSL baseada em rubi que descreve 'recursos' para estar em um estado específico em um nó. Vamos prosseguir com uma explicação passo a passo para se familiarizar com alguns conceitos do Chef que também são aplicáveis ​​ao chef-solo. Nosso objetivo é configurar um nó do Ubuntu executando um aplicativo da web Python / Django usando Gunicorn e NGINX.

Nota: Não exigimos necessariamente que o ChefDK seja instalado em nossa "estação de trabalho Chef" (nossa máquina), embora com ele possamos usar os comandos 'chef generate' para iniciar com uma estrutura de diretórios para criar livros de receitas, receitas e muito mais. Neste artigo, assumiremos que o ChefDK está instalado em nossa estação de trabalho. Os comandos foram executados usando a versão 4.7.26-1 do ChefDK.

(Tudo a partir deste ponto, a menos que especificado de outra forma, deve ser executado em nossa máquina, também chamada de 'Estação de trabalho do chef')

Criando o livro de receitas

Os livros de receitas no chef são unidades reutilizáveis ​​que contêm tudo o necessário para suportar um cenário de configuração. Os livros de receitas podem conter várias 'receitas' e 'receitas' consistem principalmente em padrões de recursos. default.rbé a receita padrão que será executada quando o livro de receitas for referenciado em uma lista de execução . Receitas diferentes permitem a separação de preocupações. Para este tutorial, no entanto, adicionaremos todas as declarações de recurso em um arquivo principal de receita, que é o default.rb.

Crie uma pasta chamada "my-chef-project" e crie uma pasta dentro dela chamada "livros de receitas". De ./my-chef-project/cookbooks/, execute:

$ chef generate cookbook my-cookbook

Nossa estrutura de diretórios agora ficará assim:

.
└── my-chef-project
└── cookbooks
└── my-cookbook
├── CHANGELOG.md
├── LICENSE
├── Policyfile.rb
├── README.md
├── chefignore
├── kitchen.yml
├── metadata.rb
├── recipes
│ └── default.rb
├── spec
│ ├── spec_helper.rb
│ └── unit
│ └── recipes
│ └── default_spec.rb
└── test
└── integration
└── default
└── default_test.rb

Adicionando pacotes

O primeiro passo para configurar nosso nó é identificar quais pacotes são necessários ao nosso aplicativo. Nosso nó foi selecionado para ser Ubuntu, para que possamos contar com o gerenciador de pacotes APT para reunir as dependências. A instalação dos pacotes fornecidos pela distribuição do SO é uma tarefa fácil:

apt_update
package 'python3'
package 'python3-pip'
package 'nginx'
package 'pkg-config'
package 'libcairo2-dev'
package 'libjpeg-dev'
package 'libgif-dev'
package 'libgirepository1.0-dev'

Estes são praticamente auto-explicativos. A primeira linha atualizará o repositório apt e as seguintes linhas instalarão esses pacotes.

Nota: Os pacotes a seguir ao 'nginx' são necessários para compilar algumas das dependências do python através do pip. Estes podem diferir com base nas dependências do seu projeto python / django especificadas em requirements.txt. Você pode usar um método de tentativa e erro para determinar esses pacotes que você precisa incluir no seu livro de receitas. Para fazer isso, execute um manual sudo pip install -r requirements.txt(Nota: Isso instala os pacotes em todo o sistema!) Em uma máquina ubuntu recém-instanciada para verificar se é executada com êxito. Caso contrário, o stderr deve fornecer dicas sobre quais pacotes estão faltando.

Criando Usuários Linux

Quando terminarmos de adicionar os pacotes necessários, precisamos criar um usuário Linux não privilegiado que possua o código fonte do aplicativo.

user 'bob' do
  uid 1212
  gid 'users'
  home '/home/bob'
  shell '/bin/bash'
  password '$1$alilbito$C83FsODuq0A1pUMeFPeR10'
end

Observe que a senha é um formato de hash de sombra usado no Linux. Pode ser derivado usando o OpenSSL:

$ openssl passwd -1 -salt alilbitof mypassword

Incluindo a fonte do aplicativo

Agora vamos incluir o código fonte do aplicativo Django em nosso livro de receitas. Coloque o código-fonte dentro de ./my-chef-project/cookbooks/my-cookbook/files/default/myapp/ Criar o ./my-chef-project/cookbooks/my-cookbook/files/defaultdiretório, se ele não existir.

As instruções para copiar esses arquivos para um local remoto em nosso nó são descritas usando o recurso remote_directory :

remote_directory '/home/bob/myapp' do
  source 'myapp' # This is the name of the folder containing our source code that we kept in ./my-cookbook/files/default/
  owner 'bob'
  group 'users'
  mode '0755'
  action :create
end

Puxando as dependências python

Para instalar os pacotes python requirements.txt, podemos usar o recurso execute para executar um comando arbitrário. Nesse caso, precisamos executar o comando pip install sobre ele:

execute 'install python dependencies' do
  command 'pip3 install -r requirements.txt'
  cwd '/home/bob/myapp'
end

Nota: Lembre-se de que isso será executado como usuário root e as bibliotecas python serão instaladas em todo o sistema. Se nosso nó estiver designado para executar exclusivamente esse único aplicativo python, isso não será um problema. Apesar disso, uma opção melhor para manter as coisas limpas e saudáveis ​​é encontrar e usar um livro de receitas da comunidade que gerencia instalações de python ou 'virtualenvs'. (ou pelo menos, escreva uma série de blocos de execução para replicar isso). O uso de virtualenvs em python garante que quaisquer ferramentas de sistema baseadas em python ou outros projetos python não sejam afetados

Configurando o Gunicorn e o NGINX

Agora é hora de preparar o Gunicorn WSGI HTTP Server com o NGINX como nosso proxy reverso. O Nginx também é usado para lidar com todos os ativos estáticos do Django.

Para amarrar o Gunicorn como um serviço no Ubuntu, o Systemd pode ser usado. O recurso systemd_unit está incluído no Chef desde a versão 12.11.

systemd_unit 'gunicorn.service' do
  content({
  Unit: {
    Description: 'Django on Gunicorn',
    After: 'network.target',
  },
  Service: {
    ExecStart: '/usr/local/bin/gunicorn --workers 3 --bind localhost:8080 myapp.wsgi:application',
    User: 'bob',
    Group: 'www-data',
    WorkingDirectory: '/home/bob/myapp'
    Restart: 'always',
  },
  Install: {
    WantedBy: 'multi-user.target',
  }
  })
  action [:create, :enable, :start]
end

Agora temos que incluir uma configuração padrão de proxy NGINX neste servidor Gunicorn, como mostrado abaixo. Esse snippet pode ser usado ./my-cookbook/templates/nginx.conf.erb. Crie o diretório de modelos se ele não existir.

Nota: Os modelos do Chef suportam arquivos ruby ​​incorporados que podem conter variáveis, expressões e instruções ruby. Embora este arquivo tenha a extensão 'erb', não usamos nenhuma das instruções ou expressões ruby. Além disso, por uma questão de simplicidade, temos apenas uma configuração não HTTPS nginx aqui (lembrete gentil; por favor, não faça isso na produção!)

server {
  listen 80;
  server_name http://example.com/;

  location = /favicon.ico { access_log off; log_not_found off; }
  location /static/ {
    root /home/bob/myapp/myapp/static;
  }

  location / {
  include proxy_params;
    proxy_pass http://localhost:8080/;
  }
}

Nota: Também existe uma alternativa e uma configuração melhor, onde, por exemplo, o servidor Gunicorn está vinculado a um soquete de domínio unix em vez de a uma conexão de loopback TCP. Vale a pena explorar isso por razões de desempenho.

Para copiar essa configuração para a pasta habilitada para sites no nó, use o recurso de modelo do Chef.

template '/etc/nginx/sites-available/example.com.conf' do
  source 'nginx.conf.erb'
  owner 'root'
  group 'root'
  mode '0744'
end

A ativação de configurações no nginx normalmente é feita através da criação de um link simbólico apontando para a configuração na pasta sites-availabledo nginx sites-enabled. Os links simbólicos podem ser declarados nos livros de receitas do chef com o recurso de link , como mostrado abaixo:

link '/etc/nginx/sites-enabled/example.com.conf' do
  to '/etc/nginx/sites-available/example.com.conf'
end

e para excluir o link simbólico de configuração padrão:

link '/etc/nginx/sites-enabled/default' do
  action :delete
end

Iniciando o NGINX

E, finalmente, para ativar o serviço nginx:

service 'nginx' do
  action :enable
  action :start
end

Listas de execução

As listas de execução no chef são uma lista ordenada de funções ou receitas em um livro de receitas que serão executadas em sequência no nó. Temos um livro de receitas "meu-livro de receitas" e a receita "padrão" que precisamos executar na caixa do Ubuntu; portanto, o runlist.json no diretório do projeto ( ./my-chef-project/runlist.json) deve ficar assim:

{
  "run_list": [
    "recipe[my-cookbook::default]"
  ]
}

Etapas finais

Nosso livro de receitas para Chef solo está pronto para ser servido. É hora de provisionar uma máquina Ubuntu 18.04 e instalar o ChefDK nela:

$ ssh [email protected] 'apt-get update && yes | apt-get install curl && curl https://packages.chef.io/files/current/chefdk/4.7.45/ubuntu/18.04/chefdk_4.7.45-1_amd64.deb -o chefdk.deb && yes | dpkg -i chefdk.deb && rm chefdk.deb'

Voltando à nossa estação de trabalho do Chef , tudo o que precisamos fazer é colocar a pasta de livros de receitas dentro de um tarball, transferir esse tarball junto com o runlist.jsonnó remoto que provisionamos acima e executar o comando chef-solo:

(O comando abaixo deve ser executado dentro do nó ou no 'chef client' e não na estação de trabalho do chef)

$ chef-solo --recipe-url $(pwd)/chef-solo.tar.gz -j $(pwd)/runlist.json --chef-license=accept

Ou aqui está uma lista (para ser executada no ./my-chef-project/CWD na estação de trabalho do chef):

tar zvcf chef-solo.tar.gz ./cookbooks &&\
scp chef-solo.tar.gz runlist.json [email protected]:~/ &&\
ssh [email protected] 'chef-solo --recipe-url $(pwd)/chef-solo.tar.gz -j $(pwd)/runlist.json --chef-license=accept'

É isso aí! Observe a saída padrão ser preenchida com a atividade do Chef tentando convergir seu nó para o que você especificou nos livros de receitas. O Chef-solo instalará todas as jóias necessárias para todos os livros de receitas. Se o comando chef-solo for bem-sucedido, teremos um aplicativo Django em execução rodando atrás do nginx na caixa do Ubuntu. Navegue para o domínio / IP para testá-lo.

Nota: Lembre-se de que no django você pode precisar definir este domínio / ip na ALLOWED_HOSTSlista em settings.py.

Respondendo a mudanças

Sempre que fizermos uma alteração no conteúdo do diretório do projeto (receitas, modelos ou no código-fonte do aplicativo, etc.), basta executar o one-liner acima no diretório do projeto.

Dica: Se o livro de receitas for controlado por versão com o git (como deveria), uma boa recomendação é configurar os ganchos do git para executar essa linha única.

Hospedando o tarball (opcional)

Se você observar atentamente o último comando chef-solo, observe que o --recipe-urlobjetivo é usar um URL. Isso significa que você pode ter um fluxo de trabalho em que um IC criará seu tarball de chef-solo, fará o upload em algum lugar e configurará seu nó para extraí-lo periodicamente.

Dica: use curl para puxar o tarball alterado periodicamente como um cronjob. curl -z $filehonrará os If-Modified-Sincecabeçalhos e só fará o download do tar ball se o arquivo remoto tiver sido alterado desde o registro de data e hora no local existente $file.