12. Finalizar el archivo de docker-compose


1. Contexto del problema:

Cuando usas Docker, los contenedores tienen su propio usuario y grupo (por defecto root o un usuario genérico). Si creas archivos desde el contenedor, estos pueden quedar con permisos de root en tu máquina local, lo que te impedirá editarlos o borrarlos sin sudo.

Para evitar eso, se crea un usuario dentro del contenedor que tenga el mismo UID (User ID) que tu usuario actual en tu sistema.

2. Lo que hace el fragmento del docker-compose.yml:

En el archivo docker-compose.yml, se están pasando variables de construcción (args) al Dockerfile:

yaml
services:
  app:
    build:
      args:
        user: udemy       # Nombre del usuario dentro del contenedor
        uid: 1000         # UID que coincidirá con tu UID en el sistema

  • user: udemy: Será el nombre del usuario dentro del contenedor.

  • uid: 1000: Es el UID de tu usuario en tu máquina real. Así, los archivos creados en el contenedor tendrán el mismo UID que tu usuario local.

3. ¿Por qué echo $UID?

El comando echo $UID en la terminal muestra tu User ID actual. En Linux/macOS, el primer usuario suele tener UID 1000.

Ejemplo en la terminal:

bash
$ echo $UID
1000

Ese valor (1000 o el tuyo) es el que debes poner en uid:.

4. Lo que dice el tutorial (traducido y explicado):

"Vamos a guardar el archivo y salir, luego ejecutamos echo $UID para saber cuál es el UID del usuario actual. En mi caso es 1000. Si tú tienes otro UID, ese es el que debes usar. Luego volvemos al docker-compose.yml y lo ajustamos."

5. Resumen práctico:

  1. Verifica tu UID ejecutando en terminal:

    bash
    echo $UID

  2. Pon ese valor en docker-compose.yml bajo args: uid: TU_UID.

  3. Así, cuando el contenedor cree archivos, tendrán tu mismo usuario y permisos.

Ejemplo final de docker-compose.yml ajustado:

yaml
version: "3.8"
services:
  app:
    build:
      context: .
      args:
        user: udemy
        uid: 1000   # ← Aquí pones el resultado de `echo $UID`
    volumes:
      - .:/var/www/html

 ¡Excelente! Este paso es crucial, ya que completa la orquestación del entorno al agregar el servidor web (Nginx) y la base de datos (MySQL) al archivo docker-compose.yml.

⚙️ 12. Finalizar el Archivo Docker Compose (Nginx y MySQL)

Este tutorial te guiará a través de la adición de los servicios de Nginx y MySQL al archivo docker-compose.yml y la creación del archivo de configuración de Nginx para Laravel.

Paso 1: Limpiar Contenedores y Preparar Directorios

Primero, asegúrate de que no haya contenedores de la aplicación corriendo para evitar conflictos, y luego crea el directorio de configuración de Nginx.

  1. Detener y Eliminar Contenedores Previos:

    Si el contenedor de app del paso anterior sigue corriendo, detenlo y elimínalo junto con la red creada:

    Bash
    docker-compose down
# (Opcional, verifica que no haya contenedores)
# docker ps -a

  2. Crear Directorio de Configuración de Nginx:

    Crea la estructura de carpetas necesaria para alojar el archivo de configuración de Nginx que compartiremos con el contenedor:

    Bash
    mkdir -p docker-compose/nginx

    ** (Referencia a Imagen 12.4 Finalizar el archivo de docker-compose.png)

  3. Crear el Archivo de Configuración de Nginx:

    Crea el archivo de configuración del servidor Nginx para Laravel. Lo llamaremos app-laravel.conf:

    Bash
    nano docker-compose/nginx/app-laravel.conf

    ** (Referencia a Imagen 12.1 Finalizar el archivo de docker-compose.png)

Paso 2: Contenido del Archivo de Configuración de Nginx

Copia el siguiente código boilerplate de Nginx, el cual está optimizado para funcionar con Laravel y PHP-FPM.

Configuración de Nginx para Laravel
23 nov, 2:12
Variables de Entorno para Base de Datos
23 nov, 2:12

  • Variables de Entorno (DB): Docker Compose lee las variables ${DB_DATABASE}, ${DB_USERNAME} y ${DB_PASSWORD} de tu archivo .env de Laravel para configurar la base de datos MySQL automáticamente.

  • Red: Los tres servicios (app, nginx, db) están en la misma red laravel, permitiendo que se comuniquen usando sus nombres de servicio.

** (Referencia a Imagen 12.8 Finalizar el archivo de docker-compose.png)

Guarda (Ctrl + O, Enter) y sal (Ctrl + X).

Conclusión: El archivo docker-compose.yml está completo. Al ejecutar docker-compose up -d, se crearán tres contenedores: PHP-FPM, Nginx y MySQL, todos interconectados a través de la red bridge laravel.

En el siguiente video, verificarás si la configuración funciona correctamente y si puedes acceder a la aplicación Laravel a través del puerto 8000 de tu máquina virtual.


server {

    # Puerto donde Nginx escucha dentro del contenedor

    listen 80;


    # Rutas para logs

    error_log /var/log/nginx/error.log;

    access_log /var/log/nginx/access.log;


    # Directorio raíz del proyecto, apuntando a la carpeta 'public' de Laravel

    root /var/www/public;


    # Manejo de archivos PHP

    location ~ \.php$ {

        # Intentar el archivo .php, si no, devolver 404

        try_files $uri =404;

        # Pasar las peticiones a nuestro servicio de PHP-FPM (el nombre del contenedor 'app')

        fastcgi_pass app:9000;

        # Index principal para PHP

        fastcgi_index index.php;

        # Incluir parámetros FastCGI estándar

        include fastcgi_params;

        # Configuración para que Laravel obtenga el nombre del archivo

        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;

        fastcgi_param PATH_INFO $fastcgi_path_info;

    }


    # Reglas para URLs limpias (Clean URLs) de Laravel

    location / {

        try_files $uri $uri/ /index.php?$query_string;

        gzip_static on;

    }

}

```

* **Puntos clave:**

    * `listen 80`: Nginx escucha en el puerto 80 del contenedor.

    * `root /var/www/public`: Apunta al directorio `public` de Laravel.

    * `fastcgi_pass app:9000`: **IMPORTANTE**: Envía las peticiones PHP al contenedor `app` (el servicio de PHP-FPM), usando su nombre de servicio como *hostname* y el puerto 9000.

** (Referencia a Imagen 12.3 Finalizar el archivo de docker-compose.png)


Guarda (`Ctrl + O`, `Enter`) y sal (`Ctrl + X`).


---


### Paso 3: Finalizar el Archivo `docker-compose.yml`


Abre el archivo Compose nuevamente para añadir los servicios `nginx` y `db` (MySQL).


1.  **Modificar el Archivo `.env` (Laravel):**

    Antes de editar el Compose, es crucial asegurarse de que las variables de entorno de Laravel apunten al servicio de base de datos correcto. Abre el archivo `.env` de Laravel y cambia las variables de conexión a la base de datos:


    ```bash

    nano .env


Comentarios

Publicar un comentario

Entradas más populares de este blog

ejercicios-Crear Carpeta y Archivo de Texto en Ubuntu

https://copy.sh/v86/?profile=linux26 Ejercicios para Practicar en Terminales Online Ejercicio Básico 1 - Práctica Inicial bash # En la terminal online, escribe estos comandos: whoami pwd ls mkdir practica cd practica touch archivo1.txt ls -l Ejercicio Básico 2 - Crear y Copiar bash # Continuación del ejercicio anterior echo "Hola mundo desde terminal online" > archivo1.txt cat archivo1.txt mkdir copias cp archivo1.txt copias/ ls copias/ cat copias/archivo1.txt Ejercicio Básico 3 - Exploración bash # Explorar el sistema cd / ls cd home ls cd ~ pwd Te voy a guiar paso a paso en un ejercicio muy básico y fácil para principiantes. ¡Vamos a hacerlo juntos! Paso a Paso del Ejercicio Paso 1: Abrir la Terminal Presiona  Ctrl + Alt + T  para abrir la terminal en Ubuntu. Paso 2: Crear una Carpeta Principal bash mkdir mi_primer_ejercicio Paso 3: Entrar a la Carpeta bash cd mi_primer_ejercicio Paso 4: Crear un Archivo de Texto bash touch mi_archivo.txt Paso 5...
Leer más

Tutorial de Carpetas y Directorios en Ubuntu Linux

En Linux, todo es un archivo. A medida que te adentres en Linux, lo comprenderás, pero por ahora, tenlo en cuenta. Cada archivo está organizado en un árbol de directorios jerárquico. El primer directorio del sistema de archivos se denomina, acertadamente, directorio raíz. El directorio raíz contiene muchas carpetas y archivos, que pueden almacenar más carpetas y archivos, etc   Introducción a los Directorios en Linux En Linux (incluyendo Ubuntu), los directorios (carpetas) siguen una estructura jerárquica que comienza desde el directorio raíz ( / ). Este sistema organiza todos los archivos y programas del sistema. Estructura Básica del Sistema de Archivos text / ├── bin -> Comandos esenciales del sistema ├── etc -> Archivos de configuración ├── home -> Directorios de usuarios ├── var -> Archivos variables (logs, etc.) ├── tmp -> Archivos temporales ├── usr -> Programas y aplicaciones └── ... Comandos Básicos para Trabajar con Directorios 1. Navegación e...
Leer más

Instalar Docker en Ubuntu Server usando docker.io

  Tutorial: Instalar Docker en Ubuntu Server usando  docker.io Tutorial completo con  docker.io Paso 1: Actualizar el sistema bash sudo apt update sudo apt upgrade -y Paso 2: Instalar Docker desde los repositorios de Ubuntu bash sudo apt install docker.io Paso 3: Habilitar e iniciar el servicio Docker bash # Habilitar Docker para que inicie automáticamente sudo systemctl enable docker # Iniciar el servicio Docker sudo systemctl start docker # Verificar que el servicio está corriendo sudo systemctl status docker Paso 4: Configurar permisos de usuario Verificar si el grupo docker existe bash sudo grep docker /etc/group Agregar tu usuario al grupo docker bash sudo usermod -aG docker $USER Aplicar los cambios de grupo inmediatamente bash newgrp docker Paso 5: Verificar la instalación bash # Verificar versión de Docker docker --version # Probar Docker con un contenedor de prueba docker run hello-world Comprobación final Verificar que todo funcion...
Leer más