Docker: crear entorno de desarrollo web local – Parte II

En la parte I de Docker: crear entorno de desarrollo web local te mostré de forma clara y sencilla lo que es Docker y cómo funciona. También te facilité algunos comandos útiles que una vez que domines con más fluidez el uso de contenedores, serán tu mejor aliado.

Ahora bien, manos a la obra y comencemos a configurar nuestro entorno de desarrollo web local usando Docker. Aprovecho para recordarte que configuraremos nuestros servicios y contenedores para usar Nginx + PHP 7.2 + MySQL 5.7 y probaremos que todo funciona con una instalación de Symfony 4.

La estructura de directorios que usaremos sera esta:

Los pasos a seguir para la creación de nuestro entorno de desarrollo web local con Docker son:

1. Crear nuestros servicios y contenedores.

Docker, entre uno de sus tantas formas para generar y ejecutar contenedores de servicios, utiliza una herramienta llamada docker-compose la cual requiere de un fichero “docker-compose.yml” en donde definiremos todos aquellos servicios que deseamos para nuestro entorno de desarrollo.

Visto de forma sencilla, este fichero es como el “composer.json” de “Composer“, o el “package.json” de npm

Antes de comenzar, debemos situarnos en el directorio donde queremos tener nuestro proyecto, en mi caso suelo utilizar el directorio base “/var/www/html“.

Ejecutamos:

Seguidamente, crearemos un directorio para nuestro proyecto ejemplo de Symfony 4.

Ahora vamos a crear el resto de directorios que vamos a necesitar más adelante:

Procedemos a crear los ficheros necesarios, que en conjunto con el “docker-compose.yml” armarán nuestro entorno de desarrollo.

/var/www/html/docker-devenv-sf4/docker/app/Dockerfile

/var/www/html/docker-devenv-sf4/docker/app/php.ini

/var/www/html/docker-devenv-sf4/docker/app/xdebug.ini

/var/www/html/docker-devenv-sf4/docker/mysql/Dockerfile

/var/www/html/docker-devenv-sf4/docker/mysql/mysql.cnf

/var/www/html/docker-devenv-sf4/docker/nginx/Dockerfile

/var/www/html/docker-devenv-sf4/docker/nginx/default.template

/var/www/html/docker-devenv-sf4/docker/nginx/nginx.conf

/var/www/html/docker-devenv-sf4/docker/nginx/openssl.cnf

/var/www/html/docker-devenv-sf4/.env

Lo siguiente que haremos para poder ilustrarte y explicarte a nivel general los aspectos más importante para la definición de nuestro entorno, es crear dicho fichero “docker-compose.yml“, para esto ejecutamos:

Nuestro fichero final debe lucir de la siguiente forma:

Como puedes notar, es un simple fichero con una serie de parámetros que sirven para indicarle a docker que debe hacer, ejecutar y configurar para desplegar cada servicio en un contenedor.

Algunos parámetros hablan por sí solos, pero trataré de detallarte los más importantes.

  • build: Le indica a docker que la base del contenedor debe ser generada partiendo de un Dockerfile o una imagen de repositorio.
    • context: Le indica a al build que debe tirar de un Dockerfile para la instalación del sistema operativo y cualquier otra instrucción que se haya definido en él.
    • args: Son argumentos que se pueden pasar al Dockerfile como parte de la configuración necesaria del contenedor.
  • ports: Corresponde al mapping de puertos desde el cliente hacia el host, en nuestro caso por ejemplo para nginx, accedemos al servicio por el puerto 8008 hacia un servicio de nginx que corre en el puerto 80 dentro del contenedor.
  • depends_on: Crea dependencia entre contenedores, de tal forma que hasta que el contenedor indicado en este parámetro no este inicializado, el servicio que se esta definiendo con este parámetro, no se iniciará.
  • env_file: Su nombre lo indica, permite indicar que fichero de variables de entorno se va a utilizar para la configuración de cada contenedor de servicios.
  • volumes: Permite mapear mediante enlaces simbólicos los directorios que deseemos. En nuestro caso por ejemplo para nginx, realizamos un enlace simbólico de nuestro directorio symfony42 para que los ficheros puedan ser accedidos por el contenedor como si en realidad estuviesen dentro de el. Aquí es donde esta la magia en la cual podemos programar desde fuera del contenedor y ejecutar desde el navegador nuestra aplicación siendo el contenedor quien posee el servidor web, mysql, entre otros.

2. Generar el Build.

Para generar el build solo basta con ejecutar el siguiente comando:

Con esto, Docker, leerá el fichero que acabamos de crear y comenzará a descargar las imágenes necesarias, a crear los contenedores e instalar todo lo necesario en base a lo que hayamos predefinido anteriormente.

Este proceso puede tomar ciertos minutos ya que irá creando según los contenedores y servicios definidos en el fichero “docker-composer.yml” y ejecutando las instrucciones definidas en cada Dockerfile para la instalación de sistema operativo, servicios, configuraciones entre otros.

Si todo marcha bien, podremos pasar al paso número 3.

3. Añadir dominio al fichero “hosts”

Ya con todo preparado para el despliegue de nuestros contenedores, debemos añadir a nuestro fichero hosts un “mapping” de nuestro dominio a utilizar para el proyecto para que apunte a localhost.

Para esto debemos editar el fichero “/etc/hosts”:

y añadir lo siguiente:

4. Inicializar nuestros contenedores.

Lo siguiente es inicializar nuestros contenedores, y por ende, nuestros servicios. Para ello debemos ejecutar lo siguiente:

El parámetro -d es para ejecutar los contenedores de forma desacoplada, es decir, que una vez que se ejecuten, libere el proceso en la terminal y queden funcionando en segundo plano.

Este comando siempre va a verificar que si hubo algún cambio en nuestro fichero “docker-compose.yml“, realice el build antes de inicializar los respectivos contenedores.

También, es posible forzar hacer el build mediante el parámetro “–build“, por ejemplo:

Si todo marcha bien veremos lo siguiente:

5. Probar nuestro entorno de desarrollo.

Para probar nuestro entorno, vamos a realizar una simple instalación de Symfony 4 y probar que todo vaya bien. Los pasos a seguir son:

1.- Lo primero que haremos es, situarnos dentro del directorio del proyecto (/var/www/html/docker-devenv-sf4)

2.- Instalaremos el “Instalador de Symfony” ejecutando lo siguiente:

3.- Instalamos la versión web de Symfony 4.2:

4.- El paso anterior nos creará un nuevo directorio llamado “symfomy42” con toda la instalación de Symfony. Lo siguiente que haremos será instalar los paquetes que vienen definidos en el “composer.json” para esto:

5.- Finalmente podemos ir a nuestro navegador para verificar que todo este en orden, para ello ingresamos en la barra de de direcciones:

Nos debe aparecer esto:

Y de esta forma ya tenemos listo nuestro entorno de desarrollo web local con Docker. Puedes descargar todo el proyecto de ejemplo desde mi repositorio.

Recuerda que si tienes alguna sugerencia o pregunta, no dudes en dejar tus comentarios al final del post.

Si te gustó este post, ayúdame a que pueda servirle a muchas más personas, compartiendo mis contenidos en tus redes sociales.

Espero que este post haya sido de gran ayuda para ti, y como siempre, cualquier inquietud o duda que tengas, puedes contactarme por cualquiera de las vías disponibles, o dejando tus comentarios al final de este post. También puedes sugerir que temas o post te gustaría leer a futuro.