Categorías
Python

La creación de aplicaciones Python sin servidor El uso de AWS cáliz

 

Tabla de contenidos Configuración

  • y Config
  • Tela SetupSet el usuario SSH keysHarden passwordsInstall Ansible dependenciesSet SELinux a permisiva modeUpgrade el servidor
  • ajustar las teclas de SSH usuario
  • Harden contraseñas Instalar
  • Ansible dependencias
  • Conjunto SELinux modo permisivo
  • Actualiza el servidor
  • cordura visita
  • Ansible PrimerPlaybooksSample Playbook
  • libros de jugadas
  • de ejemplo Hosts Playbook
  • Playbook SetupHostsVariables
  • Variables
  • Playbook Roles01_server.yml02_git.yml03_postgres.yml04_dependencies.yml05_migrations.yml06_nginx.yml07_gunicorn. yml08_systemd.yml09_fix-502.yml
  • 01_server.yml
  • 02_git.yml
  • 03_postgres.yml
  • 04_dependencies.yml
  • 05_migrations.yml
  • 06_nginx.yml
  • 07_gunicorn.yml
  • 08_systemd.yml
  • 09_fix-502.yml
  • cordura Check (final)
  • Conclusión
  • ajustar las teclas de SSH contraseñas de usuario
  • Harden
  • Instalar Ansible dependencias
  • Conjunto de SELinux en modo permisivo
  • Actualice el servidor
  • libros de jugadas
  • Muestra Playbook
  • Hosts
  • Variables
  • 01_server.yml
  • 02_git.yml
  • 03_postgres.yml
  • 04_dependencies.yml
  • 05_migrations.yml
  • 06_nginx.yml
  • 07_gunicorn.yml
  • 08_systemd.yml
  • 09_fix-502.yml

en el último mensaje, que cubre todos los pasos necesarios para desarrollar y desplegar una aplicación Django en un único servidor con éxito. En este tutorial vamos a automatizar el proceso de implementación de Tela (v1.12.0) y Ansible (v2.1.3) para abordar estas cuestiones:

En concreto, se automatizará: Configuración

y Config

inicio al hacer girar una nuevo océano digital de las gotas, asegurándose de usar la imagen de Fedora 25. No instale una clave SSH preconfigurado; estaremos automatización de este proceso posterior a través de una secuencia de comandos de la tela. Dado que el proceso de implementación debe ser escalable, crear un repositorio separado para albergar a todos los scripts de implementación. Crear un directorio nuevo proyecto a nivel local, así como crear y activar un virtualenv usando Python 2.7x.

Por qué Python 2.7? Tela NO soporta Python 3. No se preocupe: Vamos a utilizar Python 3.5 cuando el suministro del servidor. Configuración

$ mkdir automated-deployments
$ cd automated-deployments
$ virtualenv env
$ source env/bin/activate

Tela

Tela es una herramienta que se utiliza para la automatización de comandos shell de rutina a través de SSH, que vamos a utilizar para:

de inicio mediante la instalación de la tela:

$ pip install fabric==1.12.0

Crear una nueva carpeta llamada “prod”, y añadir un nuevo archivo llamado fabfile.py a ella para mantener todos los scripts de la tela:

# prod/fabfile.py

import os
from fabric.contrib.files import sed
from fabric.api import env, local, run
from fabric.api import env

# initialize the base directory
abs_dir_path = os.path.dirname(
os.path.dirname(os.path.abspath(__file__)))

# declare environment global variables

# root user
env.user = 'root'

# list of remote IP addresses
env.hosts = ['']

# password for the remote server
env.password = ''

# full name of the user
env.full_name_user = ''

# user group
env.user_group = 'deployers'

# user for the above group
env.user_name = 'deployer'

# ssh key path
env.ssh_keys_dir = os.path.join(abs_dir_path, 'ssh-keys')

Tomar nota de los comentarios en línea. Asegúrese de añadir que la dirección IP del servidor remoto a la variable env.hosts. Actualización env.full_name_user también. Mantenerse a distancia de env.password actualización; vamos a llegar a ese breve. Mirar por encima de todas las variables env – que están completamente personalizable basan en la configuración de su sistema.

ajustar las teclas de SSH

Agregue el código siguiente para fabfile.py :

def start_provision():
"""
Start server provisioning
"""
# Create a new directory for a new remote server
env.ssh_keys_name = os.path.join(
env.ssh_keys_dir, env.host_string + '_prod_key')
local('ssh-keygen -t rsa -b 2048 -f {0}'.format(env.ssh_keys_name))
local('cp {0} {1}/authorized_keys'.format(
env.ssh_keys_name + '.pub', env.ssh_keys_dir))
# Prevent root SSHing into the remote server
sed('/etc/ssh/sshd_config', '^UsePAM yes', 'UsePAM no')
sed('/etc/ssh/sshd_config', '^PermitRootLogin yes',
'PermitRootLogin no')
sed('/etc/ssh/sshd_config', '^#PasswordAuthentication yes',
'PasswordAuthentication no')

install_ansible_dependencies()
create_deployer_group()
create_deployer_user()
upload_keys()
set_selinux_permissive()
run('service sshd reload')
upgrade_server()

Esta función actúa como punto de entrada para el script Tela. Además desencadenando una serie de funciones, cada uno se explica en otras medidas, que explícitamente-

  • genera un nuevo par de claves SSH en la ubicación especificada dentro de su sistema local de copias
  • el contenido de la clave pública al archivo authorized_keys Marcas
  • cambios en el archivo sshd_config distancia para impedir el acceso del superusuario y desactivar la autenticación sin contraseña

Impedir el acceso SSH para el usuario root es un paso opcional, pero se recomienda, ya que garantiza que nadie tiene derechos de superusuario.

Crear un directorio para sus claves SSH en la raíz del proyecto: las contraseñas de usuario

├── prod
│ └── fabfile.py
└── ssh-keys

Harden

Este paso incluye la adición de tres funciones diferentes, cada uno ejecutarse en serie a la contraseña de configuración SSH endurecimiento …

Crear implementador grupo

def create_deployer_group():
"""
Create a user group for all project developers
"""
run('groupadd {}'.format(env.user_group))
run('mv /etc/sudoers /etc/sudoers-backup')
run('(cat /etc/sudoers-backup; echo "%' +
env.user_group + ' ALL=(ALL) ALL") > /etc/sudoers')
run('chmod 440 /etc/sudoers')

Aquí , se añade un nuevo grupo llamado los desplegados y permisos sudo subvención a ella para que los usuarios pueden llevar a cabo procesos con privilegios de root.

Crear usuario

def create_deployer_user():
"""
Create a user for the user group
"""
run('adduser -c "{}" -m -g {} {}'.format(
env.full_name_user, env.user_group, env.user_name))
run('passwd {}'.format(env.user_name))
run('usermod -a -G {} {}'.format(env.user_group, env.user_name))
run('mkdir /home/{}/.ssh'.format(env.user_name))
run('chown -R {} /home/{}/.ssh'.format(env.user_name, env.user_name))
run('chgrp -R {} /home/{}/.ssh'.format(
env.user_group, env.user_name))

Este Función-

  • añade un nuevo usuario al grupo de los desplegados de usuario, que se definió en la última función
  • Establece el directorio SSH para mantener pares de claves SSH y concede permiso para el grupo y el usuario para el acceso que las claves directorio

Subir SSH

def upload_keys():
"""
Upload the SSH public/private keys to the remote server via scp
"""
scp_command = 'scp {} {}/authorized_keys {}@{}:~/.ssh'.format(
env.ssh_keys_name + '.pub',
env.ssh_keys_dir,
env.user_name,
env.host_string
)
local(scp_command)

Aquí, WE

  • Subir las claves SSH generadas localmente en el servidor remoto para que los usuarios no root puede acceder a través de SSH sin introducir una contraseña
  • Copiar el clave pública y las llaves autorizadas al servidor remoto en el directorio-claves ssh recién creado

instalación Ansible dependencias

Añadir la siguiente función para instalar los paquetes de dependencia para Ansible:

def install_ansible_dependencies():
"""
Install the python-dnf module so that Ansible
can communicate with Fedora's Package Manager
"""
run('dnf install -y python-dnf')

Tenga en cuenta que este es específico para el Fedora Linux distro, como vamos a utilizar el módulo de DNF para instalar paquetes, pero podría variar según la distribución.

Conjunto de SELinux en modo permisivo

La siguiente función establece SELinux en modo permisivo. Esto se hace para superar los posibles errores Nginx 502 Pasarela incorrecta.

def set_selinux_permissive():
"""
Set SELinux to Permissive/Disabled Mode
"""
# for permissive
run('sudo setenforce 0')

De nuevo, esto es específico de la distro Fedora Linux.

Actualiza el servidor

Por último, la actualización del servidor:

def upgrade_server():
"""
Upgrade the server as a root user
"""
run('dnf upgrade -y')
# optional command (necessary for Fedora 25)
run('dnf install -y python')
run('reboot')

cordura comprobar

Con esto, hemos terminado con el guión de la tela. Antes de ejecutarlo, asegúrese de SSH en el servidor como root y cambiar la contraseña:

$ ssh root@
You are required to change your password immediately (root enforced)
Changing password for root.
(current) UNIX password:
New password:
Retype new password:

Asegúrese de actualizar env.password con la nueva contraseña. Salir del servidor y el regreso a la terminal local, a continuación, ejecutar la tela:

$ fab -f ./prod/fabfile.py start_provision

Si todo iba bien, se generan nuevas claves SSH, y se le pedirá que cree una contraseña (asegúrese de hacer esto!):

Generating public/private rsa key pair.
Enter passphrase (empty for no passphrase):
Enter same passphrase again:

Una serie de tareas se ejecutará. Una vez creado el usuario programa de implementación, se le pedirá que agregue una contraseña para el usuario del

[104.236.66.172] out: Changing password for user deployer.

-que a continuación, tendrá que introducir cuando se cargan las claves SSH:

deployer@104.236.66.172s password:

Después de este script finaliza con éxito, usted ya NO ser capaz de iniciar sesión en el servidor remoto como usuario raíz. En su lugar, sólo se podrá utilizar el usuario no root implementador.

Pruébalo: Se espera que

$ ssh root@
Permission denied (publickey,gssapi-keyex,gssapi-with-mic).

Este. Entonces, cuando RUN

$ ssh -i ./ssh-keys/104.236.66.172_prod_key deployer@104.236.66.172

-usted debe ser capaz de conectarse bien:

[deployer@fedora-512mb-nyc2-01 ~]$

Ansible Primer

Ansible es una gestión de la configuración y la herramienta de aprovisionamiento se utiliza para automatizar tareas de implementación a través de SSH.

Puede disparar tareas Ansible individuales en contra de los servidores de aplicaciones de su shell remota y ejecutar tareas sobre la marcha. Las tareas también se pueden combinar en libros de jugadas – una colección de múltiples juega , donde cada juego define ciertas tareas específicas que se requieran durante el proceso de implementación. Se ejecutan en contra de los servidores de aplicación durante el proceso de implementación. Libros de jugadas están escritos en YAML.

libros de jugadas

libros de jugadas consisten en una arquitectura modular de la siguiente manera:

  • Las tareas son una colección de múltiples tareas que deben llevarse a cabo durante el proceso de implementación.
  • Manipuladores proporcionan una manera de accionar un conjunto de operaciones cuando un módulo realiza un cambio en el servidor remoto (mejor como ganchos).
  • plantillas

  • , en este contexto, se utiliza generalmente para especificar algunos archivos de configuración relacionados con el módulo – como nginx. La mirada de

Muestra del libro de estrategias

Ahora vamos a un solo archivo de ejemplo del libro de estrategias:

---
# My Ansible playbook for configuring Nginx
- hosts: all

vars:
http_port: 80
app_name: django_bootstrap

tasks:
- name: Install nginx
dnf: name=nginx state=latest

- name: Create nginx config file
template: src=django_bootstrap.conf dest=/etc
ginx/conf.d/{{ app_name }}.conf
become: yes
notify:
- restart nginx

handlers:
- name: Restart nginx
service: name=nginx state=restarted enabled=yes
become: yes

Aquí, hemos definido: los ejércitos

  • como anfitriones: todos, lo que indica que el libro de jugadas se ejecutará en todos los servidores que se enumeran en el inventario / hosts variables
  • http_port: 80 y nombre_apl: django_bootstrap para su uso en una plantilla
  • tareas con el fin de instalar nginx, acondicionaron el nginx config (convertido indica que necesitamos privilegios de administrador), y desencadenar el controlador de reinicio
  • Handler con el fin de reiniciar el servicio de configuración de nginx

Playbook

Ahora vamos a configurar un libro de estrategias de Django. Añadir un archivo deploy.yml al directorio “prod”:

##
# This playbook deploys the whole app stack
##
- name: apply common configuration to server
hosts: all
user: deployer
roles:
- common

El anterior fragmento de colas junto a los anfitriones Ansible, usuarios y roles. Los anfitriones

Añadir un archivo de hosts (formato de texto plano) en el directorio “prod” y la lista de los servidores bajo sus respectivos nombres de roles. Estamos aprovisionamiento de un solo servidor aquí:

[common]

En el fragmento anterior, común se refiere al nombre de la función. En virtud de las funciones que tenemos una lista de direcciones IP que se deben configurar. Asegúrese de añadir la dirección IP del servidor remoto en lugar de . Variables

Ahora definimos las variables que serán utilizadas por los papeles. Añadir una nueva carpeta dentro de “prod” c todo Ed “group_vars”, a continuación, crear un nuevo archivo c todo ed todo (formato de texto plano) dentro de esa carpeta. A continuación, especifique las siguientes variables para comenzar con:

# App Name
app_name: django_bootstrap

# Deployer User and Groups
deployer_user: deployer
deployer_group: deployers

# SSH Keys Directory
ssh_dir:

Asegúrese de actualizar . Para obtener la ruta correcta, dentro de la raíz del proyecto, ejecute:

$ cd ssh-keys
$ pwd
/Users/michael.herman/repos/realpython/automated-deployments/ssh-keys

Con estos archivos en su lugar, ahora estamos listos para coordinar nuestro proceso de implementación con todas las funciones que necesita llevarse a cabo en el servidor. Roles

Playbook

Una vez más, libros de jugadas son simplemente una colección de diferentes obras de teatro, y todas estas jugadas se ejecuta con funciones específicas. Crear un nuevo directorio llamado “roles” dentro “prod”.

¿Usted cogió el nombre de la función en el archivo deploy.yml ?

Luego dentro del directorio “papeles” añadir un nuevo directorio llamado “común” – el papel. Los roles se compone de “tareas”, “manipuladores”, y “plantillas”. Añadir un nuevo directorio para cada uno.

Una vez hecho esto la estructura de archivos debe ser algo como esto:

├── prod
│ ├── deploy.yml
│ ├── fabfile.py
│ ├── group_vars
│ │ └── all
│ ├── hosts
│ └── roles
│ └── common
│ ├── handlers
│ ├── tasks
│ └── templates
└── ssh-keys
├── 104.236.66.172_prod_key
├── 104.236.66.172_prod_key.pub
└── authorized_keys

Todas las obras se definen en un directorio “tareas”, a partir de un archivo main.yml . Este archivo sirve como punto de entrada para las tareas todo Playbook. Es simplemente una lista de múltiples archivos YAML que deben ser ejecutados en orden.

crear ese archivo ahora dentro del directorio “tareas”, a continuación, añadir la siguiente a la misma:

##
# Configure the server for the Django app
##
- include: 01_server.yml
- include: 02_git.yml
- include: 03_postgres.yml
- include: 04_dependencies.yml
- include: 05_migrations.yml
- include: 06_nginx.yml
- include: 07_gunicorn.yml
- include: 08_systemd.yml
# - include: 09_fix-502.yml

Ahora, vamos a crear cada tarea. Asegúrese de añadir un nuevo archivo para cada tarea en el directorio “tareas” y añadir el código que acompaña a cada archivo. Si se pierde, consulte el repositorio.

01_server.yml

##
# Update the DNF package cache and install packages as a root user
##
- name: Install required packages
dnf: name={{item}} state=latest
become: yes
with_items:
- vim
- fail2ban
- python3-devel
- python-virtualenv
- python3-virtualenv
- python-devel
- gcc
- libselinux-python
- redhat-rpm-config
- libtiff-devel
- libjpeg-devel
- libzip-devel
- freetype-devel
- lcms2-devel
- libwebp-devel
- tcl-devel
- tk-devel
- policycoreutils-devel

Aquí, una lista de todos los paquetes del sistema que necesita ser instalado.

02_git.yml

##
# Clone and pull the repo
##
- name: Set up git configuration
dnf: name=git state=latest
become: yes

- name: Clone or pull the latest code
git: repo={{ code_repository_url }}
dest={{ app_dir }}

Añadir las siguientes variables para los group_vars / todos los archivos :

# Github Code's Repo URL
code_repository_url: https://github.com/realpython/django-bootstrap

# App Directory
app_dir: /home/{{ deployer_user }}/{{app_name}}

Asegúrese de que tenedor a continuación, el clon del repositorio django-arranque, a continuación, actualizar la variable code_repository_url a la URL de su tenedor.

03_postgres.yml

##
# Set up and configure postgres
##
- name: Install and configure db
dnf: name={{item}} state=latest
become: yes
with_items:
- postgresql-server
- postgresql-contrib
- postgresql-devel
- python-psycopg2

- name: Run initdb command
raw: postgresql-setup initdb
become: yes

- name: Start and enable postgres
service: name=postgresql enabled=yes state=started
become: yes

- name: Create database
postgresql_db: name={{ app_name }}
become_user: postgres
become: yes

- name: Configure a new postgresql user
postgresql_user: db={{ app_name }}
name={{ db_user }}
password={{ db_password }}
priv=ALL
role_attr_flags=NOSUPERUSER
become: yes
become_user: postgres
notify:
- restart postgres

actualización group_vars / todas con la configuración de base de datos necesaria para el libro de jugadas:

# DB Configuration
db_url: postgresql://{{deployer_user}}:{{db_password}}@localhost/{{app_name}}
db_password: thisissomeseucrepassword
db_name: "{{ app_name }}"
db_user: "{{ deployer_user }}"

actualización de la variable contraseña_bd con una contraseña segura.

¿Notaste que reiniciamos el servicio postgres dentro del archivo main.yml con el fin de aplicar los cambios después de la base de datos se configura? Esta es nuestra primera manejador. Crear un nuevo archivo llamado main.yml en la carpeta “manipuladores”, a continuación, añadir lo siguiente: group_vars

- name: restart postgres
service: name=postgresql state=restarted
become: yes

04_dependencies.yml

##
# Set up all the dependencies in a virtualenv required by the Django app
##
- name: Create a virtualenv directory
file: path={{ venv_dir }} state=directory

- name: Install dependencies
pip: requirements={{ app_dir }}/requirements.txt
virtualenv={{ venv_dir }}
virtualenv_python=python3.5

- name: Create the .env file for running ad-hoc python commands in our virtualenv
template: src=env.j2 dest={{ app_dir }}/.env
become: yes

actualización / todas así:

# Application Dependencies Setup
venv_dir: '/home/{{ deployer_user }}/envs/{{ app_name }}'
venv_python: '{{ venv_dir }}/bin/python3.5'

Añadir una plantilla llamada env.j2 a la carpeta “plantillas”, y añadir las siguientes variables de entorno:

#!/bin/bash
export DEBUG="True"
export DATABASE_URL="postgresql://deployer:thisissomeseucrepassword@localhost/django_bootstrap"
export DJANGO_SECRET_KEY="changeme"
export DJANGO_SETTINGS_MODULE="config.settings.production"

tener mucho cuidado con las variables de entorno y sus valores en env.j2 ya que estos se utilizan para obtener el proyecto de Django en funcionamiento.

05_migrations.yml

##
# Run db migrations and get all static files
##
- name: Make migrations
shell: ". {{ app_dir }}/.env; {{ venv_python }} {{ app_dir }}/manage.py makemigrations "
become: yes

- name: Migrate database
django_manage: app_path={{ app_dir }}
command=migrate
virtualenv={{ venv_dir }}

- name: Get all static files
django_manage: app_path={{ app_dir }}
command=collectstatic
virtualenv={{ venv_dir }}
become: yes

06_nginx.yml

##
# Configure nginx web server
##
- name: Set up nginx config
dnf: name=nginx state=latest
become: yes

- name: Write nginx conf file
template: src=django_bootstrap.conf dest=/etc
ginx/conf.d/{{ app_name }}.conf
become: yes
notify:
- restart nginx

Añadir la siguiente variable a group_vars / todas :

# Remote Server Details
server_ip:
wsgi_server_port: 8000

no se olvide de actualización . Luego agregar el controlador a manipuladores / main.yml :

- name: restart nginx
service: name=nginx state=restarted enabled=yes
become: yes

Entonces tenemos que añadir la plantilla django_bootstrap.conf . Crear ese archivo en el directorio “plantillas”, a continuación, añadir el código:

upstream app_server {
server 127.0.0.1:{{ wsgi_server_port }} fail_timeout=0;
}

server {
listen 80;
server_name {{ server_ip }};
access_log /var/log
ginx/{{ app_name }}-access.log;
error_log /var/log
ginx/{{ app_name }}-error.log info;

keepalive_timeout 5;

# path for staticfiles
location /static {
autoindex on;
alias {{ app_dir }}/staticfiles/;
}

location / {
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header Host $http_host;
proxy_redirect off;

if (!-f $request_filename) {
proxy_pass http://app_server;
break;
}
}
}

07_gunicorn.yml

##
# Set up Gunicorn and configure systemd to execute gunicorn_start script
##
- name: Create a deploy directory
file: path={{ deploy_dir }} state=directory
become: yes

- name: Create the gunicorn_start script for running our app from systemd service
template: src=gunicorn_start
dest={{ deploy_dir }}/gunicorn_start
become: yes

- name: Make the gunicorn_start script executable
raw: cd {{ deploy_dir }}; chmod +x gunicorn_start
become: yes

Añadir más variables a groups_vars / todas :

# Deploy Dir in App Directory
deploy_dir: '{{ app_dir }}/deploy'

# WSGI Vars
django_wsgi_module: config.wsgi
django_settings_module: config.settings.production
django_secret_key: 'changeme'
database_url: '{{ db_url }}'

Añadir la plantilla gunicorn_start :

#!/bin/bash

### Define script variables

# Name of the app
NAME='{{ app_name }}'
# Path to virtualenv
VIRTUALENV='{{ venv_dir }}'
# Django Project Directory
DJANGODIR='{{ app_dir }}'
# The user to run as
USER={{ deployer_user }}
# The group to run as
GROUP={{deployer_group }}
# Number of worker processes Gunicorn should spawn
NUM_WORKERS=3
# Settings file that Gunicorn should use
DJANGO_SETTINGS_MODULE={{django_settings_module}}
# WSGI module name
DJANGO_WSGI_MODULE={{ django_wsgi_module }}

### Activate virtualenv and create environment variables

echo "Starting $NAME as `whoami`"
# Activate the virtual environment
cd $VIRTUALENV
source bin/activate
cd $DJANGODIR
# Defining the Environment Variables
export DJANGO_SECRET_KEY='{{ django_secret_key }}'
export DATABASE_URL='{{ db_url }}'
export DJANGO_SETTINGS_MODULE=$DJANGO_SETTINGS_MODULE
export PYTHONPATH=$DJANGODIR:$PYTHONPATH

### Start Gunicorn

exec gunicorn ${DJANGO_WSGI_MODULE}:application \
--name $NAME \
--workers $NUM_WORKERS \
--user=$USER --group=$GROUP \
--log-level=debug \
--bind=127.0.0.1:8000

08_systemd.yml

##
# Set up systemd for executing gunicorn_start script
##
- name: write a systemd service file
template: src=django-bootstrap.service
dest=/etc/systemd/system
become: yes
notify:
- restart app
- restart nginx

Añadir la plantilla – django-bootstrap.service :

#!/bin/sh

[Unit]
Description=Django Web App
After=network.target

[Service]
PIDFile=/var/run/djangoBootstrap.pid
User={{ deployer_user }}
Group={{ deployer_group }}
ExecStart=/bin/sh {{ deploy_dir }}/gunicorn_start
Restart=on-abort

[Install]
WantedBy=multi-user.target

Añadir lo siguiente a los manipuladores:

- name: restart app
service: name=django-bootstrap state=restarted enabled=yes
become: yes

09_fix-502.yml

##
# Fix the 502 nginx error post deployment
#
- name: Fix nginx 502 error
raw: cd ~; cat /var/log/audit/audit.log | grep nginx | grep denied | audit2allow -M mynginx; semodule -i mynginx.pp
become: yes

cordura Check (final)

con el virtualenv activado, instale Ansible localmente:

$ pip install ansible==2.1.3

Crear un nuevo archivo llamado deploy_prod.sh en la raíz del proyecto para ejecutar el libro de jugadas, asegurándose de actualización :

#!/bin/bash

ansible-playbook ./prod/deploy.yml --private-key=./ssh_keys_prod_key -K -u deployer -i ./prod/hosts -vvv

a continuación, ejecute comandos para ejecutar el libro de jugadas:

$ sh deploy_prod.sh

Si se produce algún error, consulte el terminal para obtener información sobre cómo corregirlos. Una vez fijado, ejecutar la secuencia de comandos de despliegue de nuevo. Cuando la secuencia de comandos se realiza visita Dirección IP del servidor para verificar su aplicación web Django es vivo y funcionando!

Asegúrese de quitar los comentarios de esta línea en prod / roles / comunes / tareas / main.yml si ves el error 502, lo que indica que hay un problema con la comunicación entre nginx y Gunicorn:

# - include: 09_fix-502.yml

Entonces ejecutar el libro de jugadas de nuevo.

Si se ejecuta el libro de jugadas más de una vez, asegúrese de comentar la ejecución de comandos initdb encuentra en 03_postgres.yml ya que necesita ejecutar sólo una vez. De lo contrario, se generan errores al intentar reiniciar el servidor de base de datos.

Conclusión

Este puesto proporciona un conocimiento básico de cómo puede automatizar la configuración de un servidor con Tela y Ansible. Libros de jugadas Ansible son particularmente poderosos ya que se puede automatizar casi cualquier tarea en el servidor a través de un archivo YAML. Con suerte, ahora puede comenzar a escribir sus propios libros de jugadas e incluso utilizar en su lugar de trabajo para los servidores listos para la producción de configure.

favor añadir preguntas y comentarios a continuación. El código completo se puede encontrar en los-implementaciones automatizadas de repositorio.

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *