Páginas

sábado, 27 de agosto de 2016

Implementar Wordress con docker-compose



La creación de un nuevo entorno de alojamiento web puede llevar mucho tiempo, especialmente si tiene que hacerlo a menudo. Docker Compose, después de la configuración inicial, simplifica el proceso de instalación en un solo comando de implementación reduciendo el tiempo y el esfuerzo necesarios.

Docker es una plataforma recipiente que permite la instalación de software simple y rápida en cualquier sistema o sistema operativo. Se envuelve la pieza de software en un sistema de archivos completo que incluye todo lo que necesita para funcionar como el código, herramientas del sistema y las bibliotecas. Esto permite que cualquiera pueda empaquetar una aplicación con sus dependencias en un bloque de construcción estandarizada.

Install Docker en una máquina Linux (Ubuntu 16.04).

Utilizar Docker Compose requiere tener el demonio Docker corriendo en su máquina local o servidor en la nube. Instalar Docker es fácil:

# wget -qO- https://test.docker.com/ | sh

Añadir el usuario al grupo docker
# usermod -aG docker carles

Activar el reenvío de paquetes

# echo “1” > /proc/sys/net/ipv4/ip_forward

$ sudo cat /proc/sys/net/ipv4/ip_forward
1

Hacer el cambio permanente archivo /etc/sysctl.conf

# Uncomment the next line to enable packet forwarding for IPv4
net.ipv4.ip_forward=1

# sysctl -p
net.ipv4.ip_forward = 1


Install Docker Compose

# curl -L https://github.com/docker/compose/releases/download/1.8.0/\
docker-compose-`uname -s`-`uname -m` > /usr/local/bin/docker-compose
# chmod +x /usr/local/bin/docker-compose

Comprobar la instalación
# docker-compose -v
docker-compose version 1.8.0, build 94f7016

Configurar WordPress con docker-compose

WordPress está oficialmente disponible en Docker Hub, pero no va a crear un sitio web que funcione por sí mismo, requiere una base de datos para almacenar el contenido. MariaDB es un sistema de gestión de base de datos relacional creada por una comunidad de desarrolladores, un reemplazo para MySQL y disponible oficialmente en Docker.

La creación de containers con docker-compose pasa por crear dos archivos, un dockerfile y un docker-compose.yml en el directorio de trabajo.

Creando el directorio de trabajo

$ mkdir ~/wordpress-compose
$ cd ~/wordpress-compose


Al archivo Dockerfile añadimos las siguientes líneas

FROM orchardup/php5
ADD . /code



Ahora creamos el archivo docker-compose.yml, que dirá a Docker como iniciar los containers Wordpress y MariaDB.

nano docker-compose.yml

Copiar en los segmentos del ejemplo y establecer los parámetros en el archivo. Sustituya la de la base de datos e con los valores correspondientes a su servidor en la nube. Para este lab el valor en la máquina local es - 8585:80. Asegúrese de que la contraseña es la misma para ambas variables de entorno de manera que WordPress sea capaz de acceder a la base de datos. restart: always inicia los containers al iniciar el sistema (máquina local).


wordpress:
image: wordpress
links:
– mariadb:mysql
environment:
– WORDPRESS_DB_PASSWORD=password
ports:
– IP public server:80:80
volumes:
– ./code:/code
– ./html:/var/www/html
mariadb:
image: mariadb
environment:
– MYSQL_ROOT_PASSWORD=password
– MYSQL_DATABASE=wordpress
volumes:
– ./database:/var/lib/mysql
Mi archivo docker-compose.yml es:

wordpress:
   image: wordpress
   restart: always
   links:
     - mariadb:mysql
   environment:
     - WORDPRESS_DB_PASSWORD=password
   ports:
     - 8585:80
   volumes:
     - ./code:/code
     - ./html:/var/www/html
mariadb:
   image: mariadb
   restart: always
   environment:
     - MYSQL_ROOT_PASSWORD=password
     - MYSQL_DATABASE=wordpressbase
   volumes:
     - ./database:/var/lib/mysql


Ahora cree los nuevos contenedores con comando a continuación. Esto inicia ambos contenedores en segundo plano y los deja ejecuntando. Si desea ver la salida de los contenedores omita la -d para desplegar las aplicaciones en primer plano.

docker-compose up -d

A continuación, puede abrir la IP o de dominio de su servidor de WordPress en su navegador web para probar la instalación y será dirigido a la página de configuración inicial de WordPress.


Si desea realizar cambios en la configuración, sólo tiene que actualizar los archivos y ejecutar docker-compose de nuevo. Si docker-compose detecta cambios en la configuración o la imagen ha cambiado desde que el contenedor fue creado, aplica los cambios para y vuelve a crear los containers preservando al mismo tiempo los volúmenes montados. Genial.



Por ejemplo, puede comprobar si hay actualizaciones en las imágenes de WordPress y
 MariaDB y aplicar cambios en los containers utilizando los comandos:

docker-compose pull
docker-compose up -d

Listando el directorio de trabajo:



Otros comandos docker-compose:

# Iniciar todos los containers detenidos en el directorio de trabajo
$ docker-compose start

# Parar todos los containers en ejecución en el directorio de trabajo
$ docker-compose stop

# Valida y muestra la configuración
$ docker-compose config

# Lista todos los containers en ejecución en el directorio de trabajo
$ docker-compose ps

# Detiene y elimina todos los containers en el directorio de trabajo
$ docker-compose down

$ docker-compose logs


docker-compose crea containers a la vez que simplifica la gestión de aplicaciones, docker-compose va un paso más allá y te permite agrupar varios contenedores dentro de un directorio de trabajo individual.



carles@note:~$ docker ps
CONTAINER ID  IMAGE     COMMAND                  CREATED STATUS              PORTS                  NAMES
6330c10fbaf7  wordpress “/entrypoint.sh apach”   About   About     0.0.0.0:8585->80/tcp  wordpresscompose_wordpress_1
1e3fe89acca1  mariadb    “docker-entrypoint.sh”   About an hour   Up About   3306/tcp       wordpresscompose_mariadb_1


Antes de continuar con la construcción de su nuevo sitio WordPress, asegúrese de prestar atención a la seguridad en su cloud server. En este sentido vamos a implementar Iptables firewall con política de deny por defecto.

Para empezar, tendrá que instalar el paquete iptables-persistent si no lo ha hecho ya. Esto nos permitirá guardar el conjunto de reglas que sera aplicado de forma automática en el arranque:

Instalar el servicio Persistent Firewall

$ sudo apt-get update
$ sudo apt-get install iptables-persistent

Durante la instalación, se le preguntará si desea guardar sus reglas actuales, conteste sí.

Primero renombre el archivo actual:

# mv /etc/iptables/rules.v4 /etc/iptables/rules.v4-bak

Este es el nuevo contenido del archivo /etc/iptables/rules.v4:

# vi /etc/iptables/rules.v4

######################################################################
*filter
# Allow all outgoing, but drop incoming and forwarding packets by default
:INPUT DROP [0:0]
:FORWARD DROP [0:0]
:OUTPUT ACCEPT [0:0]

# Custom per-protocol chains
:UDP - [0:0]
:TCP - [0:0]
:ICMP - [0:0]

# Acceptable UDP traffic

# Docker rules copiadas de rules.v4
:DOCKER - [0:0]
:DOCKER-ISOLATION - [0:0]
-A FORWARD -j DOCKER-ISOLATION
-A FORWARD -o docker0 -j DOCKER
-A FORWARD -o docker0 -m conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT
-A FORWARD -i docker0 ! -o docker0 -j ACCEPT
-A FORWARD -i docker0 -o docker0 -j ACCEPT
-A DOCKER-ISOLATION -j RETURN
# Acceptable TCP traffic
-A TCP -p tcp --dport 22 -j ACCEPT

# Acceptable ICMP traffic

# Boilerplate acceptance policy
-A INPUT -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT
-A INPUT -i lo -j ACCEPT

# Drop invalid packets
-A INPUT -m conntrack --ctstate INVALID -j DROP

# Pass traffic to protocol-specific chains
## Only allow new connections (established and related should already be handled)
## For TCP, additionally only allow new SYN packets since that is the only valid
## method for establishing a new TCP connection
-A INPUT -p udp -m conntrack --ctstate NEW -j UDP
-A INPUT -p tcp --syn -m conntrack --ctstate NEW -j TCP
-A INPUT -p icmp -m conntrack --ctstate NEW -j ICMP

# Reject anything that's fallen through to this point
## Try to be protocol-specific w/ rejection message
-A INPUT -p udp -j REJECT --reject-with icmp-port-unreachable
-A INPUT -p tcp -j REJECT --reject-with tcp-reset
-A INPUT -j REJECT --reject-with icmp-proto-unreachable

# Commit the changes
COMMIT

*raw
:PREROUTING ACCEPT [0:0]
:OUTPUT ACCEPT [0:0]
COMMIT

*nat
:PREROUTING ACCEPT [0:0]
:INPUT ACCEPT [0:0]
:OUTPUT ACCEPT [0:0]
:POSTROUTING ACCEPT [0:0]
:DOCKER - [0:0]
-A PREROUTING -m addrtype --dst-type LOCAL -j DOCKER
-A OUTPUT ! -d 127.0.0.0/8 -m addrtype --dst-type LOCAL -j DOCKER
-A POSTROUTING -s 172.17.0.0/16 ! -o docker0 -j MASQUERADE
-A DOCKER -i docker0 -j RETURN
COMMIT

*security
:INPUT ACCEPT [0:0]
:FORWARD ACCEPT [0:0]
:OUTPUT ACCEPT [0:0]
COMMIT

*mangle
:PREROUTING ACCEPT [0:0]
:INPUT ACCEPT [0:0]
:FORWARD ACCEPT [0:0]
:OUTPUT ACCEPT [0:0]
:POSTROUTING ACCEPT [0:0]
COMMIT
###################################################################
Guarde y cierre el archivo
Puede probar el archivo de errores de sintaxis escribiendo este comando.:
# iptables-restore -t /etc/iptables/rules.v4

Si no hay errores de sintaxis, puede aplicar las reglas escribiendo:
# service iptables-persistent reload

Listar todas las reglas e imprimor las direcciones IP y números de puerto en formato numérico.

$ sudo iptables -L -n
Chain INPUT (policy DROP)
target     prot opt source               destination         
ACCEPT     all  --  0.0.0.0/0            0.0.0.0/0            ctstate RELATED,ESTABLISHED
ACCEPT     all  --  0.0.0.0/0            0.0.0.0/0           
DROP       all  --  0.0.0.0/0            0.0.0.0/0            ctstate INVALID
UDP        udp  --  0.0.0.0/0            0.0.0.0/0            ctstate NEW
TCP        tcp  --  0.0.0.0/0            0.0.0.0/0            tcp flags:0x17/0x02 ctstate NEW
ICMP       icmp --  0.0.0.0/0            0.0.0.0/0            ctstate NEW
REJECT     udp  --  0.0.0.0/0            0.0.0.0/0            reject-with icmp-port-unreachable
REJECT     tcp  --  0.0.0.0/0            0.0.0.0/0            reject-with tcp-reset
REJECT     all  --  0.0.0.0/0            0.0.0.0/0            reject-with icmp-proto-unreachable

Chain FORWARD (policy DROP)
target     prot opt source               destination         
DOCKER-ISOLATION  all  --  0.0.0.0/0            0.0.0.0/0           
DOCKER     all  --  0.0.0.0/0            0.0.0.0/0           
ACCEPT     all  --  0.0.0.0/0            0.0.0.0/0            ctstate RELATED,ESTABLISHED
ACCEPT     all  --  0.0.0.0/0            0.0.0.0/0           
ACCEPT     all  --  0.0.0.0/0            0.0.0.0/0           

Chain OUTPUT (policy ACCEPT)
target     prot opt source               destination         

Chain DOCKER (1 references)
target     prot opt source               destination         
ACCEPT     tcp  --  0.0.0.0/0            172.17.0.3           tcp dpt:80

Chain DOCKER-ISOLATION (1 references)
target     prot opt source               destination         
RETURN     all  --  0.0.0.0/0            0.0.0.0/0           

Chain ICMP (1 references)
target     prot opt source               destination         

Chain TCP (1 references)
target     prot opt source               destination         
ACCEPT     tcp  --  0.0.0.0/0            0.0.0.0/0            tcp dpt:22

Chain UDP (1 references)
target     prot opt source               destination

Imprimir todas las cadenas como iptables-save

$ sudo iptables -S
-P INPUT DROP
-P FORWARD DROP
-P OUTPUT ACCEPT
-N DOCKER
-N DOCKER-ISOLATION
-N ICMP
-N TCP
-N UDP
-A INPUT -m conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT
-A INPUT -i lo -j ACCEPT
-A INPUT -m conntrack --ctstate INVALID -j DROP
-A INPUT -p udp -m conntrack --ctstate NEW -j UDP
-A INPUT -p tcp -m tcp --tcp-flags FIN,SYN,RST,ACK SYN -m conntrack --ctstate NEW -j TCP
-A INPUT -p icmp -m conntrack --ctstate NEW -j ICMP
-A INPUT -p udp -j REJECT --reject-with icmp-port-unreachable
-A INPUT -p tcp -j REJECT --reject-with tcp-reset
-A INPUT -j REJECT --reject-with icmp-proto-unreachable
-A FORWARD -j DOCKER-ISOLATION
-A FORWARD -o docker0 -j DOCKER
-A FORWARD -o docker0 -m conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT
-A FORWARD -i docker0 ! -o docker0 -j ACCEPT
-A FORWARD -i docker0 -o docker0 -j ACCEPT
-A DOCKER -d 172.17.0.3/32 ! -i docker0 -o docker0 -p tcp -m tcp --dport 80 -j ACCEPT
-A DOCKER-ISOLATION -j RETURN
-A TCP -p tcp -m tcp --dport 22 -j ACCEPT

Bibliografía:
- https://www.digitalocean.com/community/tutorials/how-to-install-wordpress-and-phpmyadmin-with-docker-compose-on-ubuntu-14-04
- https://docs.docker.com/
- https://github.com/nazar-pc/docker-webserver

Unix es genial!