PHP y MySQL con Docker y Docker Compose

• 01/11/2023
• 0 Comentarios

Guía Completa de PHP y MySQL con Docker

Hola lector, bienvenido a mi blog sobre desarrollo web. En este artículo voy a explicar paso a paso cómo configurar un entorno de desarrollo para PHP y MySQL utilizando Docker y Docker Compose.

Si eres desarrollador web, seguramente conoces lo complicado que puede ser configurar tu entorno de desarrollo. Entre versiones de PHP, manejar bases de datos, y dependencias del sistema operativo, puede convertirse en todo un dolor de cabeza. ¡Pero no temas! Docker y Docker Compose han llegado para facilitarnos las cosas.

Con Docker podremos crear contenedores ligeros y portables para nuestras aplicaciones, asegurando que nuestro código se ejecute de la misma forma sin importar el entorno. Docker Compose nos permitirá definir y ejecutar flujos de trabajo multi-contenedores, permitiendo levantar ambientes de desarrollo completos con un simple comando.

En este artículo veremos:

• - Una introducción a PHP y MySQL, las tecnologías que utilizaremos.

• - Qué es Docker y Docker Compose, y cómo nos ayudan en el desarrollo.

• - Cómo crear imágenes Docker para PHP y MySQL.

• - Configuración de la red y volúmenes entre contenedores.

• - Definición de servicios con Docker Compose.

• - Ventajas que obtendremos en nuestros flujos de trabajo.

Al finalizar, tendremos un ambiente de desarrollo totalmente funcional y portable para crear aplicaciones PHP con bases de datos MySQL. Todo desplegado de forma automática con Docker Compose. ¡Manos a la obra!

Introducción a PHP y MySQL

PHP es un lenguaje de programación interpretado que se ejecuta del lado del servidor. Lo podemos usar para generar páginas web dinámicas que accedan a información de bases de datos, entre muchas otras cosas. Es open source, multiplataforma, y muy amigable para desarrolladores.

Algunas de las características que han hecho de PHP uno de los lenguajes backend más populares son:

• - Sintaxis sencilla similar a C y Perl.

• - Código embebido directamente en HTML.

• - Manejo integrado de bases de datos como MySQL y PostgreSQL.

• - Multiplataforma, funciona en Windows, Linux y Mac.

• - Alta compatibilidad con servidores web como Apache.

• - Enorme comunidad y disponibilidad de recursos.

MySQL es un sistema de gestión de bases de datos relacional open source, también muy popular en entornos de desarrollo web. Permite almacenar datos estructurados y realizar operaciones sobre ellos de forma muy rápida y eficiente.

Algunas de las razones que han hecho a MySQL la base de datos favorita para PHP son:

• - Alta velocidad en lecturas y escrituras de datos.

• - Facilidad de uso y configuración.

• - Modelo de permiso y seguridad sólido.

• - Replicación y balanceo de carga integrados.

• - Integración perfecta con lenguajes como PHP.

• - Totalmente open source y gratuita.

Juntos, PHP y MySQL forman una combinación sumamente potente para el desarrollo de aplicaciones web dinámicas. PHP se encarga de la lógica de la aplicación y la interacción con el usuario, mientras MySQL provee un rápido almacenamiento y recuperación de datos. Desde blogs hasta tiendas online, pasando por foros y sistemas de administración de contenidos.

Una de las ventajas de utilizar estas tecnologías es la enorme comunidad que existe alrededor. Resolver problemas, encontrar código de ejemplo y librerías es sumamente sencillo. ¡Y es totalmente open source!

---

¿Qué es Docker y Docker Compose?

Antes de meternos de lleno con PHP y MySQL, veamos qué son Docker y Docker Compose y cómo nos facilitarán el desarrollo.

Docker

Docker es una plataforma open source que nos permite crear, desplegar y ejecutar aplicaciones en contenedores.

Los contenedores nos permiten empaquetar una aplicación o servicio con todas sus dependencias y librerías necesarias, creando así un paquete estandarizado y portable.

Esto trae grandes ventajas comparado con las máquinas virtuales tradicionales:

• - Los contenedores comparten el kernel y recursos con el sistema host, haciéndolos muy livianos.

• - La separación de conceptos entre aplicaciones y sistema operativo.

• - Los contenedores se pueden crear y destruir mucho más rápido que las VM.

• - Ocupan muy poco espacio en disco y memoria.

• - Facilitan mucho la portabilidad entre distintos sistemas.

Docker nos provee las herramientas para poder crear, ejecutar y administrar estos contenedores de forma simple e intuitiva.

Veamos algunos de los conceptos clave de Docker:

• - Imágenes: Plantillas read-only que contienen el sistema operativo, aplicaciones, librerías y archivos de configuración necesarios. De las imágenes creamos los contenedores.

• - Contenedores: Instancias en ejecución de una imagen Docker. Disponen de un entorno aislado con sus propios procesos, red, almacenamiento, etc.

• - Dockerfile: Archivo que define los pasos necesarios para crear una imagen Docker.

• - Registros: Repositorios donde almacenar y distribuir imágenes Docker, como Docker Hub.

• - Volúmenes: Permiten compartir datos entre el host y los contenedores.

• - Redes: Posibilitan la comunicación entre contenedores y con el exterior.

Con Docker podremos crear contenedores reutilizables y portable para servicios como PHP, MySQL, Nginx, etc. Y unirlos para crear nuestra aplicación.

Docker Compose

Docker Compose es una herramienta que nos permite definir y ejecutar flujos de trabajo multi-contenedor de una forma sencilla e intuitiva.

Con Compose creamos un archivo YAML que define los distintos servicios que forman nuestra aplicación (bases de datos, servidores web, filas de mensajes, etc). Luego, con un simple comando, podemos crear e iniciar todos los servicios desde el archivo de configuración.

Algunas de las funciones que nos brinda Docker Compose son:

• - Definir servicios para levantar contenedores.

• - Configurar redes para permitir la comunicación entre contenedores.

• - Especificar reglas de dependencia entre servicios.

• - Compartir volúmenes de datos entre servicios.

• - Establecer variables de entorno.

• - Escalar los servicios.

• - Ver logs de ejecución de forma sencilla.

Docker Compose nos permitirá automatizar el levantamiento de entornos de forma simple y manteniendo la portabilidad. Un archivo YAML definirá todos los servicios requeridos para ejecutar nuestra aplicación PHP con MySQL.

---

Configurando PHP y MySQL con Docker

Luego de ver la potencia de Docker y Docker Compose, es hora de poner manos a la obra y ver cómo crear nuestro entorno de desarrollo PHP y MySQL.

Lo primero será crear imágenes Docker para PHP y MySQL que podamos reutilizar fácilmente en el futuro. Luego las configuraremos para que puedan comunicarse entre sí.

Creando las imágenes Docker

Empezaremos creando imágenes Docker oficiales para PHP y MySQL desde Docker Hub:

docker pull php:7.4-fpm
docker pull mysql:8.2

Esto descargará las últimas versiones de las imágenes para usar de base. Ahora crearemos nuestro propio Dockerfile para personalizar la imagen PHP:

# Dockerfile

FROM php:7.4-fpm

# Instalar extensiones necesarias
RUN docker-php-ext-install pdo pdo_mysql

# Habilitar módulos deseados
RUN docker-php-ext-enable sodium

# Limpiar cache
RUN apt-get clean && rm -rf /var/lib/apt/lists/*

Con este Dockerfile instalaremos las extensiones PDO y PDO para MySQL, necesarias para conectar PHP con la base de datos. También habilitaremos el módulo sodium.

Ahora podemos crear nuestra propia imagen PHP personalizada:

docker build -t my_php .

El script sql cubrirá la creación de bases de datos y tablas iniciales, usuarios, etc. Esta imagen MySQL ya tendrá una estructura preconfigurada.

# Dockerfile

FROM mysql:8.2

# Copiar script con configuración inicial
COPY db_init.sql /docker-entrypoint-initdb.d/

El script sql cubrirá la creación de bases de datos y tablas iniciales, usuarios, etc. Esta imagen MySQL ya tendrá una estructura preconfigurada.

Construimos la imagen:

docker build -t my_mysql .

¡Listo! Ya tenemos imágenes Docker para PHP 7.4 y MySQL 5.7 totalmente personalizadas para nuestras necesidades. Ahora debemos unirlas para que funcionen en conjunto.

Configurando la red y volúmenes entre contenedores

Para que PHP y MySQL se puedan comunicar, los contenedores deberán estar en la misma red Docker.

Crearemos una red puente:

docker network create my_network

También mapearemos un volumen de datos desde nuestro sistema host hasta el contenedor MySQL, para evitar perder información si este se detiene:

docker run -d \\
  --name mysql \\
  --net my_network \\
  -v ~/data:/var/lib/mysql \\
  my_mysql

Así los datos de MySQL persistirán en la carpeta ~/data de nuestra máquina host.

Ahora iniciamos el servidor PHP, vinculándolo a la misma red:

docker run -d \\
  --name php \\
  --net my_network \\
  -v $(pwd):/var/www/html \\
  my_php

También montaremos nuestro directorio actual en el host, para sincronizar archivos entre este y el contenedor PHP.

Finalmente, creamos un archivo .env para que PHP pueda conectarse a la base de datos:

# .env

MYSQL_HOST=mysql
MYSQL_USER=root
MYSQL_PASSWORD=secret
MYSQL_DB=my_db

Indicando el host mysql y las credenciales que configuramos en el script sql.

¡Perfecto! Nuestro entorno de desarrollo PHP + MySQL con Docker está funcionando. Pero levantar todo este proceso manualmente puede resultar tedioso. Es aquí donde Docker Compose nos facilitará las cosas.

---

Agregando Docker Compose al flujo de trabajo

Una vez que tenemos las imágenes de Docker para PHP y MySQL, podemos proceder a crear un sencillo proyecto PHP para probar la configuración.

Comencemos creando la estructura de archivos para nuestro proyecto:

/project
  /public
    index.php
  /src
    db.php
  .env
  docker-compose.yml

El archivo index.php en /public será el punto de entrada a nuestra aplicación. La carpeta /src contendrá archivos de configuración y código PHP. El archivo .env almacenará variables de entorno.

Ahora definamos los servicios de Docker Compose en docker-compose.yml:

version: '3'

services:

  db:
    image: mysql:8.2
    volumes:
      - ./data:/var/lib/mysql
    environment:
      MYSQL_ROOT_PASSWORD: secretpassword
      MYSQL_DATABASE: sampledb
    ports:
      - "3306:3306"

  web:
    build: ./php
    ports:
      - "8080:80"
    volumes: 
      - ./src:/var/www/html
    environment:
      MYSQL_HOST: db
      MYSQL_USER: root
      MYSQL_PASSWORD: secretpassword
      MYSQL_DB: sampledb

volumes:
  data:

Esto levanta un contenedor MySQL y otro para nuestra aplicación PHP.

El Dockerfile para el servicio web instalará las extensiones necesarias:

FROM php:7.4-fpm
RUN docker-php-ext-install pdo pdo_mysql

Ahora podemos conectarnos a MySQL dentro de /src/db.php:

<?php
// db.php 

$host = $_ENV["MYSQL_HOST"];
$user = $_ENV["MYSQL_USER"];
$pass = $_ENV["MYSQL_PASSWORD"];
$db = $_ENV["MYSQL_DB"];

$conn = new mysqli($host, $user, $pass, $db);

// Consultar base de datos
$query = "SELECT * FROM sample_table";
$result = $conn->query($query);

while($row = $result->fetch_assoc()) {
  echo $row["text_column"] ."<br>";
}

Y finalmente renderizar la salida en index.php:

<?php
// index.php
include "db.php";

¡Listo! Al ejecutar docker-compose up tendremos una aplicación PHP funcional conectada a MySQL dentro de contenedores Docker. Podemos expandir esta configuración base para un proyecto más robusto. Para poder acceder a nuestra web deberemos abrir nuestro navegador favorito e ir a la url localhost:8080 además si queremos ver nuestra base de datos debemos abrir nuestro IDE de bases de datos favorito y crear una nueva conexión con el hostname 127.0.0.1 y puerto 3306

¡Sencillo! Docker Compose se encarga de iniciar los contenedores, vincular redes, montar volúmenes, y todo lo necesario de forma automática a partir del archivo yaml.

Podríamos también crear archivos Compose distintos para desarrollo, testeo y producción. Y ejecutar comandos como start, stop, logs o acceder a una shell de forma fácil.

Algunos comandos útiles de Docker Compose:

# Levantar contenedores en segundo plano
docker-compose up -d

# Detener todos los contenedores
docker-compose stop

# Ver logs en tiempo real
docker-compose logs -f

# Ejecutar comando dentro del servicio php
docker-compose exec CONTENEDOR_ID php script.php

# Reconstruir imagenes
docker-compose build

Docker Compose nos permite automatizar y estandarizar nuestro flujo de trabajo para levantar entornos de desarrollo de forma simple e intuitiva.

---

Ventajas para el desarrollo web

Hemos visto cómo Docker y Docker Compose nos permiten configurar un ambiente de desarrollo estandarizado y portable para PHP y MySQL.

Esto trae grandes ventajas para nuestro flujo de trabajo de desarrollo web:

• - Entornos consistentes: Los contenedores proveen entornos idénticos sin importar dónde ejecutemos nuestra aplicación. Esto facilita el desarrollo, testeo y despliegue.

• - Aislamiento de dependencias: Cada pieza tiene sus propias librerías y configuraciones internas. Evita conflictos entre versiones.

• - Integración continua: Podemos automatizar la generación de entornos para ejecutar nuestras pruebas.

• - Colaboración: Los equipos pueden usar el mismo ambiente de desarrollo estandarizado.

• - Despliegue: Pasar de desarrollo a producción es tan simple como correr un contenedor.

• - Portabilidad: Llevar nuestra aplicación de un lugar a otro sin complicaciones.

• - Escalabilidad: Docker y Kubernetes proveen funciones avanzadas para escalar nuestros contenedores.

• - Alta disponibilidad: Los contenedores y servicios pueden ser replicados para eliminar puntos únicos de falla.

• - Optimización de recursos: Los contenedores comparten recursos del sistema operativo base, reduciendo requerimientos.

Docker transforma la forma en la que desarrollamos, probamos y deployamos aplicaciones PHP con MySQL. Nos permite automatizar flujos de trabajo y reducir enormemente los dolores de cabeza. ¡Bienvenida la portabilidad y consistencia!

---

Conclusión

En este artículo vimos como Docker y Docker Compose nos permiten configurar un entorno de desarrollo estandarizado y portable para PHP y MySQL.

Creando imágenes Docker customizable logramos empaquetar PHP y MySQL con sus dependencias específicas. Luego las conectamos para permitir su comunicación a través de redes y configuramos el intercambio de datos con volúmenes.

Finalmente, utilizamos Docker Compose para automatizar la creación de nuestro ambiente de desarrollo con un simple archivo YML y un comando. Esto estandariza y facilita enormemente el levantamiento de entornos consistentes.

Los beneficios no terminan solo en la etapa de desarrollo. Docker nos permite desplegar aplicaciones de igual manera en producción, testeo, etc. Nos da la capacidad de estandarizar el ciclo de vida completo de una aplicación.

Espero que este artículo te haya dado una idea de cómo Docker puede transformar tu flujo de trabajo. Simplemente define tus aplicaciones como contenedores, automátizalos con Docker Compose