Producción usando Docker-compose¶

1. Instalar Docker: https://docs.docker.com/engine/installation/linux/docker-ce/ubuntu/

2. Instalar Docker-compose: https://docs.docker.com/compose/install/

Servicios a usar:¶

• Django
• Gunicorn (Puerto: 8080)
• Nginx (Puerto: 80 ) (Puerto para Ingresar en la aplicación: 3000)
• Mysql (Puerto: 3306) (Puerto para conectar con aplicación: 6301)
• Redis (Puerto: 6379) (Puerto para conectar con aplicación: 6300)
• Celery

Carpetas (para mantener el orden)¶

• Para guardar las aplicaciones: apps, docker_apps o workspace

• Para guardar los backups o elementos compartidos: docker_shared o dockers

Descargar la aplicación "radarsys" (Sistema Integrado de Radar)¶

• Ejecutar los siguientes comandos:

user$ cd ~/apps/
user$ svn checkout --username=<username> http://jro-dev.igp.gob.pe/svn/jro_hard/radarsys/trunk/webapp/ radarsys
user$ cd radarsys

NOTA: la dirección ~/apps/ pudo ser ~/workspace/ o ~/docker_apps/

Verificar archivos¶

• En la ruta: radarsys/radarsys/settings.py debe estar habilitado:

'HOST': 'mysql',

• En el mismo script segurarse que:

MEDIA_ROOT: 'media'

• Asimismo, la parte para "Pruebas locales" con Celery debe estar comentado y la parte para Producción debe estar descomentada.

#--Development--# (Para Pruebas Locales)
#BROKER_URL = 'redis://127.0.0.1:6300'
#CELERY_RESULT_BACKEND = 'redis://localhost:6300'
#---------------#
#--Production---# (Para Docker)
CELERY_BROKER_TRANSPORT = BROKER_URL = 'redis://%s:6379/0' % REDIS_HOST
CELERY_RESULT_BACKEND = 'redis://%s:6379/0' % REDIS_HOST
#---------------#

• En el script radarsys/apps/abs/utils/Graphics_OverJro.py, matplotlib Agg debe estar habilitado

matplotlib.use("Agg")

• En el script radarsys/radarsys/urls.py comentar para que solo nginx sirva "static":

...
#from django.contrib.staticfiles.urls import staticfiles_urlpatterns

urlpatterns = [
    ...
]

#urlpatterns += staticfiles_urlpatterns()

• Verificar archivo ".env" que contiene las variables para la creación del container:

HOST_MYSQL=mysql
HOST_REDIS=redis
MYSQL_ROOT_PASSWORD=xxxx
MYSQL_DATABASE=radarsys
MYSQL_USER=developer
MYSQL_PASSWORD=xxxx
HOST_REDIS=redis

• Verificar el archivo Dockerfile:

FROM python:2.7.11

# set working directory
RUN mkdir /radarsys
WORKDIR /radarsys

# Install python dependences
ADD requirements.txt ./requirements.txt
RUN pip install -v --timeout 120 -r requirements.txt --no-cache-dir

# Copy the main application.
COPY . ./

RUN python manage.py collectstatic --noinput

NOTA: la librería redis de python debe estar contenida en requirements.txt

• Verificar el archivo docker-compose.yml:

version: '2'
services:
  web:
    container_name: 'radarsys_web'
    build: .
    restart: always
    image: radarsys
    command: gunicorn radarsys.wsgi:application -w 2 -b :8080
    env_file: .env
    ports:
      - "8080:8080"
    links:
      - redis
      - mysql
    volumes:
      - './:/data'
    depends_on:
      - redis
      - mysql  

  redis:
    container_name: 'redis'
    image: 'redis:3.2-alpine'
    ports:
      - '127.0.0.1:6379:6379'
    volumes:
      - '/data/dockers/radarsys/redis:/data'

  celery_worker:
    image: radarsys
    env_file: .env
    command: celery -A radarsys worker -l info
    volumes_from:
      - web
    depends_on:
      - web

  mysql:
    container_name: 'mysql'
    image: 'mysql:5.6'
    env_file: .env
    ports:
      - '127.0.0.1:3306:3306'
    volumes:
      - '/data/dockers/radarsys/mysql:/var/lib/mysql'

  nginx:
    restart: always
    build: ./nginx/
    ports:
      - "3000:80"
    volumes:
      - '/data/dockers/radarsys/nginx:/data/nginx'
    volumes_from:
      - web
    links:
      - web:web

NOTA: si ya existe la imagen de algún servicio (mysql o redis) o este servicio ya se encuentra instalado en el sistema, se recomienda usar otros puertos para evitar coincidencia de puertos:

redis:
    ...
    ports:
      - '127.0.0.1:6300:6379'
    ...

mysql:
    ...
    ports:
      - '127.0.0.1:6301:3306'
    ...

• NOTA: el puerto por donde se servirá la aplicación es colocado en la descripción de nginx

nginx:
    ...
    ports:
      - "3000:80"
    ...

• NOTA: el contenido de los volumen deben estar dirigidos a la carpeta anteriormente mencionada: docker_shared o dockers

redis:
    ...
    volumes:
      - '/data/dockers/radarsys/redis:/data'

mysql:
    ...
    volumes:
      - '/data/dockers/radarsys/mysql:/var/lib/mysql'

nginx:
    ...
    volumes:
      - '/data/dockers/radarsys/nginx:/data/nginx'

• Confirmar la existencia de la carpeta nginx/ donde se encuentra el archivo Dockerfile para la creación de su imagen docker:

FROM tutum/nginx

RUN rm /etc/nginx/sites-enabled/default
ADD sites-enabled/ /etc/nginx/sites-enabled
ADD sites-enabled/radarsys /etc/nginx/conf.d/

• Confirmar la existencia del archivo radarsys dentro de la carpeta nginx/sites-enabled/:

server {

    listen 80;
    server_name sir.com;

    access_log /dev/stdout;
    error_log /dev/stdout info;

    location /static {
        alias /data/media/static;
    }

    location / {
        proxy_pass http://web:8080;
    }

}

Creación de Imagen y Container¶

• Ingresar a la carpeta donde se descargó la aplicación:

user$ cd ~/apps/radarsys

• Ejecutar los comandos:

user$ docker-compose build
user$ docker-compose up -d

NOTA: Puede tomar minutos la creación de la imagen.

• Una vez creados exitosamente los container, ingresar al docker radarsys_web :

user$ docker exec -it radarsys_web bash

• Dentro del docker radarsys_web, ejecutar las migraciones de la Base de Datos y cargar la data:

user$ python manage.py makemigrations
user$ python manage.py migrate
user$ python manage.py loaddata apps/main/fixtures/main_initial_data.json
user$ python manage.py loaddata apps/rc/fixtures/rc_initial_data.json
user$ python manage.py loaddata apps/jars/fixtures/initial_filters_data.json