2.1 Configuración del entorno de trabajo con Docker

Requisitos previos:

  1. Instalar Docker Desktop:

  2. Instalar VSCode:

    • Descargar VSCode
    • Recomendamos instalar la extensión Remote - Containers de VSCode para trabajar directamente en los contenedores.

  3. Instalar docker mySQL:

En este punto tenemos tres opciones:

  • Opción 1: Instalar el contenedor de MySQL desde cero. Puedes seguir las instrucciones de la documentación oficial de Docker para crear un contenedor MySQL, y llamarle docker_mysql.
  • Opción 2: Utilizar un contenedor MySQL ya existente. En este caso, asumimos que ya tienes un contenedor MySQL en funcionamiento con las siguientes características:
  • Opcion 3: Añadir a nuestro docker-compose.yml el contenedor de MySQL. En este caso, añadiremos un contenedor MySQL al archivo docker-compose.yml que vamos a crear a continuación.

En función de la opción elegida, tendrás que adaptar la conexión a la base de datos en el código PHP que vamos a crear. En el caso de contar ya con un contenedor MySQL en funcionamiento, o acceso a un servicio mysql ya existente, el temario presupone que estas son las credenciales de acceso:

  • Nombre del contenedor: docker_mysql (Si utilizas un contenedor MySQL)
  • IP: localhost (o host.docker.internal si estás en Windows o Mac)
  • Usuario: alumno
  • Contraseña: alumno
  • Base de datos: test

Paso 1: Preparación del proyecto

  1. Crea una carpeta para tu proyecto:

    • Abre una terminal (CMD, PowerShell, Terminal de VSCode, etc.).
    • Crea una nueva carpeta para tu proyecto y navega dentro de ella.
    mkdir mi-proyecto-php
cd mi-proyecto-php

  2. Crea la estructura de carpetas:

    Dentro de la carpeta mi-proyecto-php, crea las siguientes carpetas y archivos:

    mkdir nginx php php/conf.d mysql mysql/data mysql/tmp src
touch docker-compose.yml nginx/default.conf 
touch php/Dockerfile php/condf.d/99-xdebug.ini 
touch src/index.php

Paso 2: Configuración de docker-compose.yml

  1. Abre el archivo docker-compose.yml en tu editor de texto favorito (puede ser VSCode).

  2. Pega el siguiente contenido en el archivo docker-compose.yml:

Requisitos

Nota: En nuestro caso vamos a añadir un contenedor MySQL al archivo docker-compose.yml. Si ya tienes un contenedor MySQL en funcionamiento, puedes omitir esta sección y utilizar las credenciales de acceso que ya tienes. Las credeniciales de acceso que vamos a utilizar son las siguientes:

  • Nombre del contenedor: dk_mysql
  • IP: localhost
  • Usuario: alumno
  • Contraseña: alumno
  • Base de datos: test

El usuario alumno tiene permisos para acceder por la red a la base de datos test.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
 services:
  php:
    image: php:8.4-fpm
    build: ./php
    container_name: dk_php
    volumes:
      - ./src:/var/www/html
      - ./php/conf.d/99-xdebug.ini:/usr/local/etc/php/conf.d/99-xdebug.ini
    environment:
      - MYSQL_HOST=mysql # nombre del servicio mysql en docker-compose
      - MYSQL_USER=alumno
      - MYSQL_PASSWORD=alumno
      - MYSQL_DB=test
      - MONGODB_HOST=mysql
      - MONGODB_USER=alumno
      - MONGODB_PASSWORD=alumno
      - MONGODB_DB=test
      - MONGODB_PORT=27017

  nginx:
    image: nginx:latest
    container_name: dk_nginx
    ports:
      - "8080:80"
    volumes:
      - ./src:/var/www/html
      - ./nginx/default.conf:/etc/nginx/conf.d/default.conf
    depends_on:
      - php

  mysql:
    image: mysql:8
    container_name: dk_mysql
    environment:
      MYSQL_ROOT_PASSWORD: administrador
      MYSQL_USER: alumno
      MYSQL_PASSWORD: alumno
      MYSQL_DATABASE: test
    volumes:
      - ./mysql/data:/var/lib/mysql
      - ./mysql/tmp:/tmp
    ports:
      - "3306:3306"
    networks:
      - default

networks:
  default:
    driver: bridge

En el archivo docker-compose.yml:

  • php:
    • Utiliza la imagen php:8.4-fpm.
    • Monta el directorio src en /var/www/html dentro del contenedor.
    • Monta el archivo de configuración 99-xdebug.ini para habilitar Xdebug (opcional).
    • Define las variables de entorno para la conexión a MySQL y Mongodb.
  • nginx:
    • Utiliza la imagen nginx:latest.
    • Mapea el puerto 8080 del host al puerto 80 del contenedor.
    • Monta el directorio src y el archivo de configuración nginx/default.conf en el contenedor.
    • Depende del servicio php.
  • mysql:
    • Utiliza la imagen mysql:8.
    • Define las variables de entorno para la configuración de MySQL (usuario, contraseña, base de datos).
    • Monta los volúmenes para persistir los datos y los archivos temporales. El el Dockerfile de MySQL ya creamos el password administrador para el usuario root, y el usuario alumno con la contraseña alumno y la base de datos test.
    • Mapea el puerto 3306 del host al puerto 3306 del contenedor. (Asegúrate de que este puerto no esté en uso por otro servicio en tu máquina).

El contenido del fichero php/conf.d/99-xdebug.ini es opcional, pero si quieres usar Xdebug, puedes crear un archivo con el siguiente contenido:

zend_extension=xdebug.so

xdebug.mode=debug
xdebug.start_with_request=yes
xdebug.client_host=host.docker.internal
xdebug.client_port=9003
xdebug.log_level=0

Esto habilitará Xdebug en el contenedor PHP y permitirá la depuración remota.

Paso 3: Configuración de Nginx

  1. Abre el archivo nginx/default.conf.

  2. Pega el siguiente contenido en el archivo default.conf:

Configuración nginx

server {
   listen 80;
   server_name localhost;

   root /var/www/html;
   index index.php index.html;

   location / {
       try_files $uri $uri/ =404;
   }

   location ~ \.php$ {
       include fastcgi_params;
       fastcgi_pass php:9000;
       fastcgi_index index.php;
       fastcgi_param SCRIPT_FILENAME /var/www/html$fastcgi_script_name;
   }
}

Paso 4: Crear el Dockerfile para PHP (si lo necesitas)

  1. Abre el archivo php/Dockerfile.

  2. Pega el siguiente contenido para crear el contenedor de PHP con las extensiones necesarias, de momento las libreriás PDO y MySQL:

Sería recomendado compartir bind el directorio usr/local/etc/php/conf.d para que puedas modificar el archivo php.ini desde tu máquina host.

Dockerfile PHP

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
FROM php:8.4-fpm

# Instalar las dependencias necesarias 
RUN apt-get update && apt-get install -y \
    git \
    unzip \
    curl \
    libzip-dev \
    libpng-dev \
    libxml2-dev \
    libonig-dev \
    libssl-dev \
    libmongoc-1.0-0 \
    libjemalloc2 \
    && rm -rf /var/lib/apt/lists/*

# Instalar extensiones de PHP necesarias (como PDO y MySQL)
RUN docker-php-ext-install pdo pdo_mysql xml ctype zip 

# Instalamos Composer, gestor de dependencias de PHP
RUN curl -sS https://getcomposer.org/installer | php -- --install-dir=/usr/local/bin --filename=composer

# Instalamos Xdebug (opcional)
# RUN pecl install xdebug \
#    && docker-php-ext-enable xdebug

# Opcional: Definir directorio de trabajo
WORKDIR /var/www/html


# Configuración de PHP
RUN cp /usr/local/etc/php/php.ini-development /usr/local/etc/php/php.ini

# Instalación opcional de MongoDB
# RUN pecl install mongodb \
#    && docker-php-ext-enable mongodb

# Establecer la ruta de trabajo
WORKDIR /var/www/html

En el fichero anterior:

  1. FROM php:8.4-fpm: Utiliza la imagen base de PHP 8.2 con FPM.
  2. RUN apt-get update && apt-get install -y ...: Actualiza los repositorios e instala las dependencias necesarias para PHP y MongoDB.
  3. RUN docker-php-ext-install pdo pdo_mysql: Instala las extensiones de PHP necesarias para PDO y MySQL.
  4. RUN mv /usr/local/etc/php/php.ini-development /usr/local/etc/php/php.ini: Copia el archivo de configuración de PHP de desarrollo a producción.
  5. RUN pecl install mongodb ...: Instala la extensión de MongoDB y la habilita. (Opcional)
  6. WORKDIR /var/www/html: Establece el directorio de trabajo dentro del contenedor.

Paso 5: Crear un archivo PHP de prueba

  1. Abre el archivo src/index.php.

  2. Pega el siguiente contenido para crear un archivo PHP que se conecte a MySQL:

prueba php y conexión a MySQL

<?php
$host = getenv('MYSQL_HOST');  // IP o dominio del host
$db   = getenv('MYSQL_DB');    // Base de datos que utilizamos por defecto
$user = getenv('MYSQL_USER');  // Usuario
$pass = getenv('MYSQL_PASSWORD'); // Password

try {
    $pdo = new PDO("mysql:host=$host;dbname=$db", $user, $pass);
    $pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
    echo "<p>Conexión exitosa a la base de datos!</p>";
} catch (PDOException $e) {
    echo "<p>Error al conectar a la base de datos: " . $e->getMessage() . "</p>";
    echo "<p>Host: $host, DB: $db, User: $user, Pass: $pass</p>";
    phpinfo(); // Muestra información de PHP para depuración
}
?>

Paso 6: Levantar el entorno con Docker

  1. Abre la terminal en la carpeta del proyecto.

  2. Levanta los contenedores de Docker usando docker-compose:

docker-compose up --build

podemos añaidir -d al final del comando para que se ejecute en segundo plano:

docker-compose up --build -d

Esto descargará las imágenes necesarias y construirá los contenedores.

Las próximas veces que levantes el contenedor no será necesario usar --build, ya que no has hecho cambios en el Dockerfile ni en el docker-compose.yml. Si vuelves a utilizar --build, Docker volverá a construir la imagen, lo que puede tardar un poco más. Y puedes perder los cambios que hayas hecho en el contenedor. Par volver a levantar el contenedor, puedes usar:

docker-compose up
Si quieres que se ejecute en segundo plano, puedes añadir -d al final del comando:

docker-compose up -d

Si quieres parar el contenedor, puedes usar:

docker-compose down

Modificación de los contenedores

Si modificas el Dockerfile o el docker-compose.yml, tendrás que volver a ejecutar docker-compose up --build para que los cambios surtan efecto. Pero antes es conveniente eliminar los contenedores y las imágenes para evitar conflictos. Puedes hacerlo con:

docker-compose down --rmi all

Luego volvemos a construir los contenedores con:

docker-compose up --build

Paso 7: Verificar el entorno

  1. Una vez que los contenedores estén levantados, abre tu navegador y accede a http://localhost:8080.

  2. Deberías ver el mensaje "Conexión exitosa a la base de datos!" si todo está configurado correctamente.

Paso 8: (Opcional) Conectarse al contenedor MySQL

Si quieres interactuar directamente con la base de datos MySQL, puedes hacerlo desde tu terminal:

  1. Conectarse al contenedor MySQL con el siguiente comando:

    docker exec -it dk_mysql mysql -uroot -p

    Luego introduce la contraseña de root, debe ser administrador.

  2. Una vez dentro, puedes crear tablas, insertar datos, etc.

Paso 9: (Opcional) Usar VSCode con Docker

Para trabajar directamente en el contenedor desde VSCode:

  1. Instala la extensión Remote - Containers en VSCode.
  2. Abre la carpeta del proyecto con VSCode y haz clic en el icono "Reopen in Container" en la esquina inferior izquierda. Esto te permitirá trabajar dentro del contenedor PHP.

Paso 10: Proyectos adicionales (Laravel)

Una vez tengas todo en funcionamiento con PHP, puedes:

  1. Crear un nuevo proyecto de Laravel dentro de la carpeta src:

    docker exec -it dk_php bash
composer create-project --prefer-dist laravel/laravel mi-laravel

  2. Configurar la base de datos en .env de Laravel para que se conecte a MySQL usando las mismas credenciales que usaste en el archivo PHP.