Cómo instalar WordPress con Nginx en un contenedor Docker
Hola a todos, hoy aprenderemos cómo instalar WordPress ejecutando Nginx Web Server en un contenedor Docker. WordPress es un increíble sistema de gestión de contenido de código abierto y gratuito que ejecuta miles de sitios web en todo el mundo. Estibador es un proyecto de código abierto que proporciona una plataforma abierta para empaquetar, enviar y ejecutar cualquier aplicación como un contenedor liviano. No tiene límites de compatibilidad con idiomas, marcos o sistema de empaquetado y se puede ejecutar en cualquier lugar y en cualquier momento, desde pequeñas computadoras domésticas hasta servidores de alta gama. Los convierte en grandes bloques de construcción para implementar y escalar aplicaciones web, bases de datos y servicios de back-end sin depender de una pila o proveedor en particular.
Hoy, implementaremos un contenedor docker con el último paquete de WordPress con los requisitos previos necesarios, es decir, servidor web Nginx, PHP5, servidor MariaDB, etc. Aquí hay algunos pasos breves y sencillos para instalar con éxito un WordPress ejecutando Nginx en un contenedor Docker.
1. Instalación de Docker
Antes de comenzar realmente, debemos asegurarnos de tener Docker instalado en nuestra máquina Linux. Aquí, estamos ejecutando CentOS 7 como host, por lo que ejecutaremos yum manager para instalar la ventana acoplable usando el siguiente comando.
# yum install docker
# systemctl restart docker.service
2. Creando WordPress Dockerfile
Necesitaremos crear un Dockerfile que automatizará la instalación de wordpress y sus requisitos previos necesarios. Este Dockerfile se utilizará para crear la imagen de la instalación de WordPress que creamos. Este WordPress Dockerfile obtiene una imagen de CentOS 7 del Docker Registry Hub y actualiza el sistema con los últimos paquetes disponibles. Luego instala los softwares necesarios como Nginx Web Server, PHP, MariaDB, Open SSH Server y más, que son esenciales para que funcione el contenedor Docker. Luego ejecuta un script que inicializará la instalación de WordPress de forma inmediata.
# nano Dockerfile
Luego, necesitaremos agregar las siguientes líneas de configuración dentro de ese Dockerfile.
FROM centos:centos7 MAINTAINER The CentOS Project <cloud-ops@centos.org> RUN yum -y update; yum clean all RUN yum -y install epel-release; yum clean all RUN yum -y install mariadb mariadb-server mariadb-client nginx php-fpm php-cli php-mysql php-gd php-imap php-ldap php-odbc php-pear php-xml php-xmlrpc php-magickwand php-magpierss php-mbstring php-mcrypt php-mssql php-shout php-snmp php-soap php-tidy php-apc pwgen python-setuptools curl git tar; yum clean all ADD ./start.sh /start.sh ADD ./nginx-site.conf /nginx.conf RUN mv /nginx.conf /etc/nginx/nginx.conf RUN rm -rf /usr/share/nginx/html/* RUN /usr/bin/easy_install supervisor RUN /usr/bin/easy_install supervisor-stdout ADD ./supervisord.conf /etc/supervisord.conf RUN echo %sudo ALL=NOPASSWD: ALL >> /etc/sudoers ADD http://wordpress.org/latest.tar.gz /wordpress.tar.gz RUN tar xvzf /wordpress.tar.gz RUN mv /wordpress/* /usr/share/nginx/html/. RUN chown -R apache:apache /usr/share/nginx/ RUN chmod 755 /start.sh RUN mkdir /var/run/sshd EXPOSE 80 EXPOSE 22 CMD ["/bin/bash", "/start.sh"]
3. Creación de secuencia de comandos de inicio
Después de crear nuestro Dockerfile, necesitaremos crear un script llamado start.sh que se ejecutará y configurará nuestra instalación de WordPress. Creará y configurará bases de datos, contraseñas para wordpress. Para crearlo, necesitaremos abrir start.sh con nuestro editor de texto favorito.
# nano start.sh
Después de abrir start.sh, necesitaremos agregar las siguientes líneas de configuración.
#!/bin/bash
__check() {
if [ -f /usr/share/nginx/html/wp-config.php ]; then
exit
fi
}
__create_user() {
# Create a user to SSH into as.
SSH_USERPASS=`pwgen -c -n -1 8`
useradd -G wheel user
echo user:$SSH_USERPASS | chpasswd
echo ssh user password: $SSH_USERPASS
}
__mysql_config() {
# Hack to get MySQL up and running... I need to look into it more.
yum -y erase mariadb mariadb-server
rm -rf /var/lib/mysql/ /etc/my.cnf
yum -y install mariadb mariadb-server
mysql_install_db
chown -R mysql:mysql /var/lib/mysql
/usr/bin/mysqld_safe &
sleep 10
}
__handle_passwords() {
# Here we generate random passwords (thank you pwgen!). The first two are for mysql users, the last batch for random keys in wp-config.php
WORDPRESS_DB="wordpress"
MYSQL_PASSWORD=`pwgen -c -n -1 12`
WORDPRESS_PASSWORD=`pwgen -c -n -1 12`
# This is so the passwords show up in logs.
echo mysql root password: $MYSQL_PASSWORD
echo wordpress password: $WORDPRESS_PASSWORD
echo $MYSQL_PASSWORD > /mysql-root-pw.txt
echo $WORDPRESS_PASSWORD > /wordpress-db-pw.txt
# There used to be a huge ugly line of sed and cat and pipe and stuff below,
# but thanks to @djfiander's thing at https://gist.github.com/djfiander/6141138
# there isn't now.
sed -e "s/database_name_here/$WORDPRESS_DB/
s/username_here/$WORDPRESS_DB/
s/password_here/$WORDPRESS_PASSWORD/
/'AUTH_KEY'/s/put your unique phrase here/`pwgen -c -n -1 65`/
/'SECURE_AUTH_KEY'/s/put your unique phrase here/`pwgen -c -n -1 65`/
/'LOGGED_IN_KEY'/s/put your unique phrase here/`pwgen -c -n -1 65`/
/'NONCE_KEY'/s/put your unique phrase here/`pwgen -c -n -1 65`/
/'AUTH_SALT'/s/put your unique phrase here/`pwgen -c -n -1 65`/
/'SECURE_AUTH_SALT'/s/put your unique phrase here/`pwgen -c -n -1 65`/
/'LOGGED_IN_SALT'/s/put your unique phrase here/`pwgen -c -n -1 65`/
/'NONCE_SALT'/s/put your unique phrase here/`pwgen -c -n -1 65`/" /usr/share/nginx/html/wp-config-sample.php > /usr/share/nginx/html/wp-config.php
}
__httpd_perms() {
chown apache:apache /usr/share/nginx/html/wp-config.php
}
__start_mysql() {
# systemctl start mysqld.service
mysqladmin -u root password $MYSQL_PASSWORD
mysql -uroot -p$MYSQL_PASSWORD -e "CREATE DATABASE wordpress; GRANT ALL PRIVILEGES ON wordpress.* TO 'wordpress'@'localhost' IDENTIFIED BY '$WORDPRESS_PASSWORD'; FLUSH PRIVILEGES;"
killall mysqld
sleep 10
}
__run_supervisor() {
supervisord -n
}
# Call all functions
__check
__create_user
__mysql_config
__handle_passwords
__httpd_perms
__start_mysql
__run_supervisor
Después de agregar la configuración anterior, necesitaremos guardarla y luego salir.
4. Creación de archivos de configuración
Ahora, necesitaremos crear un archivo de configuración para el servidor web Nginx llamado nginx-site.conf.
# nano nginx-site.conf
Luego, agregaremos la siguiente configuración al archivo de configuración.
user nginx;
worker_processes 1;
error_log /var/log/nginx/error.log;
#error_log /var/log/nginx/error.log notice;
#error_log /var/log/nginx/error.log info;
pid /run/nginx.pid;
events {
worker_connections 1024;
}
http {
include /etc/nginx/mime.types;
default_type application/octet-stream;
log_format main '$remote_addr - $remote_user [$time_local] "$request" '
'$status $body_bytes_sent "$http_referer" '
'"$http_user_agent" "$http_x_forwarded_for"';
access_log /var/log/nginx/access.log main;
sendfile on;
#tcp_nopush on;
#keepalive_timeout 0;
keepalive_timeout 65;
#gzip on;
index index.html index.htm index.php;
# Load modular configuration files from the /etc/nginx/conf.d directory.
# See http://nginx.org/en/docs/ngx_core_module.html#include
# for more information.
include /etc/nginx/conf.d/*.conf;
server {
listen 80;
server_name localhost;
#charset koi8-r;
#access_log logs/host.access.log main;
root /usr/share/nginx/html;
#error_page 404 /404.html;
# redirect server error pages to the static page /50x.html
#
error_page 500 502 503 504 /50x.html;
location = /50x.html {
root html;
}
# proxy the PHP scripts to Apache listening on 127.0.0.1:80
#
#location ~ .php$ {
# proxy_pass http://127.0.0.1;
#}
# pass the PHP scripts to FastCGI server listening on 127.0.0.1:9000
#
location ~ .php$ {
root /usr/share/nginx/html;
try_files $uri =404;
fastcgi_pass 127.0.0.1:9000;
fastcgi_index index.php;
fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
include fastcgi_params;
}
# deny access to .htaccess files, if Apache's document root
# concurs with nginx's one
#
#location ~ /.ht {
# deny all;
#}
}
}
Ahora, crearemos el archivo supervisord.conf y agregaremos las siguientes líneas como se muestra a continuación.
# nano supervisord.conf
Luego, agregue las siguientes líneas.
[unix_http_server] file=/tmp/supervisor.sock ; (the path to the socket file) [supervisord] logfile=/tmp/supervisord.log ; (main log file;default $CWD/supervisord.log) logfile_maxbytes=50MB ; (max main logfile bytes b4 rotation;default 50MB) logfile_backups=10 ; (num of main logfile rotation backups;default 10) loglevel=info ; (log level;default info; others: debug,warn,trace) pidfile=/tmp/supervisord.pid ; (supervisord pidfile;default supervisord.pid) nodaemon=false ; (start in foreground if true;default false) minfds=1024 ; (min. avail startup file descriptors;default 1024) minprocs=200 ; (min. avail process descriptors;default 200) ; the below section must remain in the config file for RPC ; (supervisorctl/web interface) to work, additional interfaces may be ; added by defining them in separate rpcinterface: sections [rpcinterface:supervisor] supervisor.rpcinterface_factory = supervisor.rpcinterface:make_main_rpcinterface [supervisorctl] serverurl=unix:///tmp/supervisor.sock ; use a unix:// URL for a unix socket [program:php-fpm] command=/usr/sbin/php-fpm -c /etc/php/fpm stdout_events_enabled=true stderr_events_enabled=true [program:php-fpm-log] command=tail -f /var/log/php-fpm/php-fpm.log stdout_events_enabled=true stderr_events_enabled=true [program:mysql] command=/usr/bin/mysql --basedir=/usr --datadir=/var/lib/mysql --plugin-dir=/usr/lib/mysql/plugin --user=mysql --log-error=/var/log/mysql/error.log --pid-file=/var/run/mysqld/mysqld.pid --socket=/var/run/mysqld/mysqld.sock --port=3306 stdout_events_enabled=true stderr_events_enabled=true [program:nginx] command=/usr/sbin/nginx stdout_events_enabled=true stderr_events_enabled=true [eventlistener:stdout] command = supervisor_stdout buffer_size = 100 events = PROCESS_LOG result_handler = supervisor_stdout:event_handler
Después de agregar, guardaremos y saldremos del archivo.
5. Creación de un contenedor de WordPress
Ahora, después de terminar con la creación de configuraciones y scripts, finalmente usaremos Dockerfile para construir nuestro contenedor deseado con el último CMS de WordPress instalado y configurado de acuerdo con la configuración. Para hacerlo, ejecutaremos el siguiente comando en ese directorio.
# docker build --rm -t wordpress:centos7 .
6. Ejecución de contenedor de WordPress
Ahora, para ejecutar nuestro contenedor recién construido y abrir los puertos 80 y 22 para el servidor web Nginx y el acceso SSH respectivamente, ejecutaremos el siguiente comando.
# CID=$(docker run -d -p 80:80 wordpress:centos7)
Para verificar el proceso y los comandos ejecutados dentro del contenedor, ejecutaremos el siguiente comando.
# echo "$(docker logs $CID )"
PARA verificar si la asignación de puertos es correcta o no, ejecute el siguiente comando.
# docker ps
7. Interfaz web
Finalmente, si todo salió en consecuencia, seremos bienvenidos con WordPress cuando apunte el navegador a http: // ip-address / o http://mywebsite.com/.
Ahora, avanzaremos paso a paso a través de la interfaz web y configuraremos la configuración de WordPress, el nombre de usuario y la contraseña para el Panel de WordPress. 
Luego, use el nombre de usuario y la contraseña ingresados anteriormente en la página de inicio de sesión de WordPress.
Conclusión
Construimos y ejecutamos con éxito WordPress CMS bajo LEMP Stack ejecutándose en el sistema operativo CentOS 7 como el sistema operativo docker. Ejecutar WordPress dentro de un contenedor hace mucho más seguro para el sistema host desde la perspectiva de la seguridad. Este artículo permite configurar completamente WordPress para que se ejecute en Docker Container con Nginx Web Server. Si tiene preguntas, sugerencias o comentarios, escríbalos en el cuadro de comentarios a continuación para que podamos mejorar o actualizar nuestros contenidos. Gracias ! Disfrutar 🙂