Uso de Chef-solo para configurar una aplicación Django en Ubuntu

• Creando el libro de cocina
• Pasos finales

Hay muchas formas de automatizar el proceso de configuración y configuración de una caja. Por alguna razón, si nuestro sistema completo en este punto se compone de una sola caja, configurar una infraestructura SCM (Software Configuration Management) completa es excesivo. Los scripts de shell son una opción, pero también podríamos usar una versión simplificada de SCM que está disponible en algunas de las herramientas disponibles. Chef es una de las opciones populares y "chef-solo" es el modo de configuración independiente de Chef en el que no necesitamos un nodo adicional para actuar como un "servidor de chef". Todo lo que necesita es una URL o una ruta a un paquete de tarball que contenga libros de cocina de chef. En comparación con los scripts de shell, este tipo de enfoque es más declarativo y eficiente, y también es una buena introducción para comenzar con los procesos SCM o IaC (Infraestructura como Código).

Algunos otros beneficios de usar chef-solo:

• Composibilidad: use los libros de cocina de la comunidad del supermercado de chef u otros lugares.
• Gratis y de código abierto; licenciado bajo la licencia permisiva Apache 2.0.
• Acceso al resto del ecosistema del Chef (InSpec, ChefSpec, Cookstyle, Foodcritic, chef-shell, etc.)
• Los libros de cocina y las recetas se pueden adaptar posteriormente al modo cliente / servidor.

Y algunas desventajas:

• Algunos libros de cocina comunitarios en el supermercado Chef están desactualizados, rotos y no se mantienen.
• chef-solo no puede resolver dependencias por sí solo.

Las 'recetas' dentro de un 'libro de cocina' del chef tienen un DSL basado en rubíes que describe los 'recursos' para estar en un estado particular en un nodo. Avancemos con un tutorial para familiarizarse con algunos conceptos de Chef que también son aplicables a chef-solo. Nuestro objetivo es configurar un nodo Ubuntu que ejecute una aplicación web Python / Django usando Gunicorn y NGINX.

Nota: No necesariamente requerimos que ChefDK se instale en nuestra "estación de trabajo Chef" (nuestra máquina), aunque con ella, podemos usar los comandos 'chef generate' para comenzar con una estructura de directorio para crear libros de cocina, recetas y más. En este artículo, asumiremos que ChefDK está instalado en nuestra estación de trabajo. Los comandos se ejecutaron con la versión 4.7.26-1 de ChefDK.

(Todo desde este punto en adelante, a menos que se especifique lo contrario, debe ejecutarse en nuestra máquina, también conocida como 'Chef Workstation')

Creando el libro de cocina

Los libros de cocina en chef son unidades reutilizables que contienen todo lo necesario para admitir un escenario de configuración. Los libros de cocina pueden contener múltiples 'recetas' y 'recetas' que consisten principalmente en patrones de recursos. default.rbes la receta predeterminada que se ejecutará cuando se haga referencia al libro de cocina en una lista de ejecución . Diferentes recetas permiten la separación de las preocupaciones. Sin embargo, para este tutorial, agregaremos todas las declaraciones de recursos en un archivo de receta principal, que es el default.rb.

Cree una carpeta llamada "my-chef-project" y cree una carpeta dentro de ella llamada "libros de cocina". Desde ./my-chef-project/cookbooks/, ejecutar:

$ chef generate cookbook my-cookbook

Nuestra estructura de directorios ahora se verá así:

.
└── 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

Agregar paquetes

El primer paso para configurar nuestro nodo es identificar qué paquetes requiere nuestra aplicación. Nuestro nodo está seleccionado para ser Ubuntu, por lo que podemos confiar en el administrador de paquetes APT para recopilar las dependencias. Instalar los paquetes proporcionados por la distribución del sistema operativo es pan comido:

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'

Estos se explican por sí mismos. La primera línea actualizará el repositorio de apt y las siguientes líneas instalarán esos paquetes.

Nota: Los paquetes que siguen a 'nginx' son necesarios para compilar algunas de las dependencias de python a través de pip. Estos pueden diferir según las dependencias de su proyecto python / django especificadas en requirements.txt. Puede usar un método de prueba y error para determinar estos paquetes que debe incluir en su libro de cocina. Para hacerlo, realice un manual sudo pip install -r requirements.txt(Nota: ¡Esto instala paquetes en todo el sistema!) En una máquina ubuntu recién instanciada para ver si se ejecuta con éxito. Si no, el stderr debería darle pistas sobre qué paquetes faltan.

Crear usuarios de Linux

Una vez que hayamos terminado de agregar los paquetes requeridos, debemos crear un usuario de Linux sin privilegios que será el propietario del código fuente de la aplicación.

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

Tenga en cuenta que la contraseña es un formato de hash de sombra utilizado en Linux. Se puede derivar usando OpenSSL:

$ openssl passwd -1 -salt alilbitof mypassword

Incluyendo la fuente de la aplicación

Ahora incluyamos el código fuente de la aplicación Django en nuestro libro de cocina. Coloque el código fuente dentro ./my-chef-project/cookbooks/my-cookbook/files/default/myapp/ Cree el ./my-chef-project/cookbooks/my-cookbook/files/defaultdirectorio si no existe.

Las instrucciones para copiar estos archivos a una ubicación remota en nuestro nodo se describen utilizando el 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

Tirando de las dependencias de Python

Para instalar los paquetes de Python en requirements.txt, podemos utilizar la ejecución de recursos para ejecutar un comando arbitrario. En este caso, necesitamos ejecutar el comando pip install sobre él:

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

Nota: Tenga en cuenta que esto se ejecutará como usuario root y las bibliotecas de Python se instalarán en todo el sistema. Si nuestro nodo está designado para ejecutar exclusivamente esta única aplicación de Python, entonces no es un gran problema. A pesar de eso, una mejor opción para mantener las cosas limpias y sanas es encontrar y usar un libro de cocina comunitario que administre las instalaciones de python o 'virtualenvs'. (o al menos, escriba una serie de bloques de ejecución para replicar esto). El uso de virtualenvs en python garantiza que las herramientas del sistema basadas en python u otros proyectos de python no se verán afectados

Configurando Gunicorn y NGINX

Ahora es el momento de preparar el servidor HTTP Gunicorn WSGI con NGINX como nuestro proxy inverso. Nginx también se usa para manejar todos los activos estáticos de Django.

Para atar a Gunicorn como un servicio en Ubuntu, se puede usar Systemd. El recurso systemd_unit está incluido en Chef desde la versión 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

Ahora tenemos que incluir una configuración de proxy NGINX estándar para este servidor Gunicorn como se muestra a continuación. Este fragmento puede entrar ./my-cookbook/templates/nginx.conf.erb. Cree el directorio de plantillas si no existe.

Nota: Las plantillas de Chef admiten archivos de ruby ​​incrustados que pueden contener variables, expresiones de ruby ​​y declaraciones. Aunque este archivo tiene la extensión 'erb', no utilizamos ninguna de las declaraciones o expresiones de ruby. Además, en aras de la simplicidad, solo tenemos una configuración nginx no HTTPS aquí (recordatorio suave; ¡no hagas esto en producción!)

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: También hay una alternativa y una mejor configuración, donde, por ejemplo, el servidor Gunicorn está vinculado a un socket de dominio unix en lugar de una conexión de bucle invertido TCP. Vale la pena explorar eso por razones de rendimiento.

Para copiar esta configuración en una carpeta habilitada para sitios en el nodo, use el recurso de plantilla de Chef.

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

La activación de configuraciones en nginx normalmente se realiza mediante la creación de un enlace simbólico que apunta a la configuración sites-availableen la sites-enabledcarpeta de nginx . Los enlaces simbólicos se pueden declarar en los libros de cocina del chef con el recurso de enlace como se muestra a continuación:

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

y para eliminar el enlace simbólico de configuración predeterminado:

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

Iniciando NGINX

Y finalmente, para iniciar el servicio nginx:

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

Runlists

Las listas de ejecución en chef son una lista ordenada de roles o recetas en un libro de cocina que se ejecutará en secuencia en el nodo. Tenemos un libro de cocina "my-cookbook" y la receta "predeterminada" dentro de él que necesitamos ejecutar en el cuadro de Ubuntu, por lo que runlist.json en nuestro directorio de proyecto ( ./my-chef-project/runlist.json) debería verse así:

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

Pasos finales

Nuestro libro de cocina para Chef solo está listo para ser servido. Es hora de aprovisionar una máquina Ubuntu 18.04 e instalar ChefDK en ella:

$ ssh root@example.com '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'

Volviendo a nuestra estación de trabajo Chef , todo lo que tenemos que hacer es colocar la carpeta de libros de cocina dentro de un tarball, transferir ese tarball junto con el runlist.jsonnodo remoto que aprovisionamos anteriormente y ejecutar el comando chef-solo:

(El siguiente comando debe ejecutarse dentro del nodo o el 'cliente chef' y no en la estación de trabajo Chef)

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

O aquí hay una línea (para ejecutar desde ./my-chef-project/CWD en Chef Workstation):

tar zvcf chef-solo.tar.gz ./cookbooks &&\
scp chef-solo.tar.gz runlist.json root@example.com:~/ &&\
ssh root@example.com 'chef-solo --recipe-url $(pwd)/chef-solo.tar.gz -j $(pwd)/runlist.json --chef-license=accept'

¡Eso es! Observe cómo la salida estándar se llena con la actividad del Chef tratando de converger su nodo con lo que ha especificado en los libros de cocina. Chef-solo instalará todas las gemas necesarias para todos los libros de cocina. Si el comando chef-solo es exitoso, tendremos una aplicación Django funcionando detrás de nginx en el cuadro de Ubuntu. Navegue al dominio / IP para probarlo.

Nota: Recuerde que en django puede que necesite configurar este dominio / ip en la ALLOWED_HOSTSlista en settings.py.

Respondiendo a los cambios

Cada vez que hagamos un cambio en el contenido de nuestro directorio de proyectos (recetas, plantillas o el código fuente de la aplicación, etc.), simplemente ejecute la línea de arriba del directorio del proyecto.

Consejo: Si el libro de cocina está controlado por git (como debería), una buena recomendación es configurar los ganchos de git para ejecutar esta línea.

Hospedaje del tarball (opcional)

Si observa de cerca el último comando chef-solo, observe que --recipe-urlestá destinado a tomar una URL. Esto significa que puede tener un flujo de trabajo donde un CI construirá su tarball solo para chef, lo cargará en algún lugar y configurará su nodo para extraerlo periódicamente.

Sugerencia: use curl para extraer el tarball modificado periódicamente como un cronjob. curl -z $filerespetará los If-Modified-Sinceencabezados y solo descargará la bola de alquitrán si el archivo remoto se ha cambiado desde la marca de tiempo en el local existente $file.