Laravel Docker Setup Guide

### 1. Project Structure

Create a new directory for your project, and within it, create the following structure:

your-laravel-project/
├── docker-compose.yml
└── Dockerfile

### 2. `docker-compose.yml`

Here’s a sample `docker-compose.yml` file:

version: '3.8'

services:
  app:
    build:
      context: .
      dockerfile: Dockerfile
    container_name: laravel_app
    volumes:
      - ./src:/var/www/html
    networks:
      - laravel_network
    depends_on:
      - db
    ports:
      - "8080:80"  # Change this to the desired host port

  db:
    image: mysql:8.0
    container_name: laravel_db
    restart: always
    environment:
      MYSQL_DATABASE: laravel
      MYSQL_USER: laravel
      MYSQL_PASSWORD: password
      MYSQL_ROOT_PASSWORD: rootpassword
    volumes:
      - db_data:/var/lib/mysql
    networks:
      - laravel_network

  adminer:
    image: adminer
    container_name: adminer
    restart: always
    ports:
      - "8081:8080"  # Change this to the desired host port for Adminer
    networks:
      - laravel_network

networks:
  laravel_network:
    driver: bridge

volumes:
  db_data:

### 3. `Dockerfile`

Create a `Dockerfile` in the same directory with the following content:

# Use the official PHP image with Apache
FROM php:8.3-apache

# Install PHP extensions
RUN docker-php-ext-install pdo pdo_mysql

# Enable Apache mod_rewrite
RUN a2enmod rewrite

# Set the working directory
WORKDIR /var/www/html

# Copy existing application directory permissions
COPY --chown=www-data:www-data src/ /var/www/html

### 4. Laravel Application

1. **Create the Laravel Application**: If you haven’t already created a Laravel application, you can do so by navigating to the `src` directory and running:

composer create-project --prefer-dist laravel/laravel .

2. **Update the `.env` file**: After creating your Laravel application, update the `.env` file to match your MySQL database settings. Make sure to set the following variables:

DB_CONNECTION=mysql
   DB_HOST=db
   DB_PORT=3306
   DB_DATABASE=laravel
   DB_USERNAME=laravel
   DB_PASSWORD=password

### 5. Build and Run

From the root of your project directory (where the `docker-compose.yml` is located), run:

docker-compose up -d

This command will build the images and start the containers in detached mode.

### 6. Access Your Application

– **Laravel**: Open your browser and navigate to `http://localhost:8080` (or whatever host port you mapped).
– **Adminer**: Open your browser and navigate to `http://localhost:8081`. You can log in with the following credentials:
– **System**: MySQL
– **Server**: db
– **Username**: laravel
– **Password**: password

### 7. Stopping the Containers

To stop the containers, run:

docker-compose down

This setup should give you a working Laravel application environment using Docker. You can customize the configuration as needed for your specific use case.

### Key Features of Docker Volumes

1. **Persistence**: Data stored in volumes remains intact even if the container is stopped or removed. This is essential for applications that require persistent data storage, like databases.

2. **Sharing**: Volumes can be shared between multiple containers. This allows different containers to access and modify the same data.

3. **Isolation from Container Lifecycle**: Since volumes exist independently of containers, they can be managed (created, updated, removed) without impacting the running containers. This helps avoid data loss during container updates or deletions.

4. **Performance**: Using volumes can provide better performance than using the container's writable layer. Docker volumes are designed to be efficient and can often improve the speed of file operations.

5. **Backups and Migration**: Volumes can be easily backed up, restored, or migrated to different Docker hosts, making it simpler to manage data over time.

### How to Use Volumes

Volumes can be created and managed using the Docker CLI or defined in a `docker-compose.yml` file. Here’s how to use them in both contexts:

#### Creating a Volume

You can create a volume using the following command:

docker volume create my_volume

#### Using a Volume in a Container

You can mount a volume to a container when you run it. For example:

docker run -d -v my_volume:/data my_image

In this case, the volume `my_volume` will be mounted to the `/data` directory inside the container.

#### Using Volumes in `docker-compose.yml`

In your `docker-compose.yml` file, you can define a volume like this:

version: '3.8'

services:
  app:
    image: my_image
    volumes:
      - my_volume:/data

volumes:
  my_volume:

### Summary

In summary, Docker volumes are a powerful feature that provides a way to manage persistent data for containers, ensuring data integrity and facilitating data sharing across multiple containers. They are essential for applications that need to maintain state across container restarts and deployments.

### Understanding `./src`

1. **Relative Path**: The `.` at the beginning indicates that `src` is a directory located in the current working directory where the `docker-compose.yml` file is located. The path `./src` means "the `src` directory in the current directory."

2. **Application Code**: Typically, in a Laravel project, the `src` directory will contain all the application code, including:
– Laravel framework files
– Configuration files
– Routes
– Controllers
– Views
– Assets (CSS, JavaScript, images, etc.)

3. **Docker Volume Mapping**: In your `docker-compose.yml` file, you’ll see a line like this:

volumes:
     - ./src:/var/www/html

This line indicates that the `src` directory on your host machine (your local filesystem) is mapped to `/var/www/html` inside the Docker container running your Laravel application.

– **Host Directory (`./src`)**: This is where you’ll write and modify your Laravel application code on your local machine.
– **Container Directory (`/var/www/html`)**: This is where the web server (Apache in this case) looks for files to serve. By mapping the two, any changes made in the `src` directory on your host will be reflected inside the container immediately, allowing for a smooth development experience.

### Example Structure

Here’s an example of what your project structure might look like:

your-laravel-project/
├── docker-compose.yml
├── Dockerfile
└── src/
    ├── app/
    ├── bootstrap/
    ├── config/
    ├── database/
    ├── public/
    ├── resources/
    ├── routes/
    ├── storage/
    └── tests/

### Summary

In summary, `./src` is a directory in your project where your Laravel application resides. It is used in the Docker configuration to ensure that the application code is accessible to the web server running inside the Docker container. This setup facilitates easy development and testing of your application.

### Project Structure

Given that your `docker-compose.yml` and Laravel application files are in the same directory, your project structure would look like this:

your-laravel-project/
├── docker-compose.yml
├── Dockerfile
├── app/
├── bootstrap/
├── config/
├── database/
├── public/
├── resources/
├── routes/
├── storage/
└── tests/

### Updated `docker-compose.yml`

With this structure, your `docker-compose.yml` file should look like this:

version: '3.8'

services:
  app:
    build:
      context: .
      dockerfile: Dockerfile
    container_name: laravel_app
    volumes:
      - .:/var/www/html  # Maps the current directory to the container
    networks:
      - laravel_network
    depends_on:
      - db
    ports:
      - "8080:80"  # Change this to your desired host port

  db:
    image: mysql:8.0
    container_name: laravel_db
    restart: always
    environment:
      MYSQL_DATABASE: laravel
      MYSQL_USER: laravel
      MYSQL_PASSWORD: password
      MYSQL_ROOT_PASSWORD: rootpassword
    volumes:
      - db_data:/var/lib/mysql
    networks:
      - laravel_network

  adminer:
    image: adminer
    container_name: adminer
    restart: always
    ports:
      - "8081:8080"  # Change this to your desired host port for Adminer
    networks:
      - laravel_network

networks:
  laravel_network:
    driver: bridge

volumes:
  db_data:

### Key Changes

– **Volume Mapping**: Instead of mapping just `./src`, it now maps `.` (the current directory) to `/var/www/html` in the container. This means all Laravel files in your project directory will be accessible inside the container, allowing for easy development and testing.

### Summary

This setup allows you to keep your Docker configuration flexible and maintainable while ensuring that your entire Laravel application is easily accessible within the container. You can continue developing your application without worrying about copying files into the container or losing changes when the container restarts.

IlluminateDatabaseQueryException

SQLSTATE[HY000] [2002] php_network_getaddresses: getaddrinfo for db failed: No such host is known. (Connection: mysql, SQL: select table_name as `name`, (data_length + index_length) as `size`, table_comment as `comment`, engine as `engine`, table_collation as `collation` from information_schema.tables where table_schema = 'laravel' and table_type in ('BASE TABLE', 'SYSTEM VERSIONED') order by table_name)

Here are some steps to troubleshoot and resolve this issue:

### 1. Check the Database Service Name

In your `.env` file, ensure that the database connection settings are correctly pointing to the database service name specified in your `docker-compose.yml` file. It should look something like this:

DB_CONNECTION=mysql
DB_HOST=db  # This should match the service name in docker-compose.yml
DB_PORT=3306
DB_DATABASE=laravel
DB_USERNAME=laravel
DB_PASSWORD=password

### 2. Ensure the Database Service is Running

Make sure that the MySQL service is up and running. You can check the status of your containers with the following command:

docker-compose ps

You should see the `laravel_db` container running. If it’s not running, check the logs to see what went wrong:

docker-compose logs db

### 3. Confirm Network Configuration

Ensure that all your services are on the same Docker network. Since you have defined a custom network (`laravel_network`), all services should be able to communicate with each other. You can verify that they are on the same network by running:

docker network ls

Then inspect the network:

docker network inspect <network_name>

### 4. Restart the Docker Services

Sometimes, just restarting the services can resolve connectivity issues. You can do this by running:

docker-compose down
docker-compose up -d

### 5. Wait for MySQL to Initialize

MySQL can take some time to start up, especially if it’s creating the database for the first time. If you try to run migrations immediately after starting the services, Laravel may attempt to connect to MySQL before it’s ready. You might want to introduce a small delay before running the migrations, or you can use the `wait-for-it` script or similar methods to ensure the MySQL service is available before running commands.

### 6. Recheck Connection Parameters

If you've modified the MySQL credentials in the `docker-compose.yml`, ensure that the `.env` file reflects the correct settings. For example:

environment:
  MYSQL_DATABASE: laravel
  MYSQL_USER: laravel
  MYSQL_PASSWORD: password
  MYSQL_ROOT_PASSWORD: rootpassword

Ensure these values match those in your `.env` file.

### 7. Test Connection from the Laravel Container

You can also manually check if the Laravel container can connect to the database by executing a shell in the app container and trying to ping the `db` service:

docker-compose exec app bash
ping db

If you can ping the `db`, then the issue might be with your database settings. If you cannot, it’s likely a network issue.

### Summary

If you've verified the database service name, ensured that the service is running, checked network configurations, and still face issues, please let me know, and we can dive deeper into the specifics!

### 1. Verify Database Host in `.env`

Ensure that the database host in your `.env` file is correctly set to the service name defined in your `docker-compose.yml` file. The `DB_HOST` should be set to `db` as follows:

DB_HOST=db

### 2. Check Docker Network

Since your `docker-compose.yml` defines a custom network, ensure that the Laravel application can resolve the `db` hostname:

– Enter the Laravel container:

docker-compose exec app bash

– Once inside the container, try to ping the database service:

ping db

If you receive responses, it confirms that the hostname `db` is resolvable.

### 3. Inspect the MySQL Container Logs

Check the logs for the MySQL container to see if there are any errors that might indicate issues with initialization or connections:

docker-compose logs db

Look for any errors related to startup or configuration.

### 4. Try Connecting Manually

While inside the Laravel container, you can try to connect to MySQL manually using the MySQL client. First, make sure the MySQL client is installed in the container, then attempt to connect:

apt-get update && apt-get install -y default-mysql-client
mysql -h db -u laravel -p

When prompted, enter the password specified in your `.env` file (`password` if you followed the previous examples). If this works, it indicates that the connection from the Laravel container to the MySQL container is functional.

### 5. Check Docker Compose Version

Ensure you're using a compatible version of Docker and Docker Compose. You can check your versions with:

docker --version
docker-compose --version

### 6. Rebuild Containers

If you've made any changes to the `.env` file or the `docker-compose.yml`, you might need to rebuild the containers to ensure that all settings are correctly applied:

docker-compose down
docker-compose up --build -d

### 7. Database Initialization Time

If the database is still initializing, Laravel might try to connect before MySQL is fully ready. You can introduce a delay or check for the service readiness before running migrations. A simple way to do this in a development environment is to run:

sleep 10  # Waits for 10 seconds
php artisan migrate

### 8. Verify Firewall or Host Settings

Sometimes, firewall settings on your machine can prevent proper communication between the containers. Ensure that Docker is allowed to manage network connections on your host machine.

### Summary

By following these troubleshooting steps, you should be able to identify and resolve the connection issue between your Laravel application and the MySQL database. If the problem persists, please share any error messages or logs that might provide more insight!

### 1. Check Document Root Configuration

Make sure that Apache is pointing to the correct document root. For Laravel, the document root should be the `public` directory. In your `Dockerfile`, you may need to explicitly set the document root. However, if you’re using the standard `php:8.3-apache` image, it should automatically point to `/var/www/html/public`. Ensure you are copying the files correctly:

COPY --chown=www-data:www-data src/ /var/www/html

This line copies all files into `/var/www/html`, so you should have:

/var/www/html
├── app/
├── bootstrap/
├── config/
├── database/
├── public/       # This should be your document root
├── resources/
├── routes/
├── storage/
└── tests/

### 2. Adjust Apache Configuration

If necessary, you can create an Apache configuration file to explicitly set the document root and other settings. Create a new file named `000-default.conf` in the same directory as your `Dockerfile`:

<VirtualHost *:80>
    DocumentRoot /var/www/html/public

    <Directory /var/www/html/public>
        AllowOverride All
        Require all granted
    </Directory>
</VirtualHost>

Then modify your `Dockerfile` to copy this configuration file into the Apache configuration directory:

COPY 000-default.conf /etc/apache2/sites-available/000-default.conf

### 3. Enable Apache Mod Rewrite

Make sure that the `mod_rewrite` module is enabled in Apache, which is necessary for Laravel routing. Your Dockerfile should include the command to enable it:

RUN a2enmod rewrite

### 4. Permissions Issue

Make sure that the permissions for your Laravel application files and directories are set correctly. Laravel requires certain directories to be writable:

– `storage`
– `bootstrap/cache`

You can set the appropriate permissions in your Dockerfile by adding:

RUN chown -R www-data:www-data /var/www/html/storage /var/www/html/bootstrap/cache
RUN chmod -R 775 /var/www/html/storage /var/www/html/bootstrap/cache

### 5. Update and Rebuild

After making the changes above, ensure you rebuild your Docker containers:

docker-compose down
docker-compose up --build -d

### 6. Check Apache Logs

If you’re still encountering issues, check the Apache error logs for more details. You can do this by accessing the app container:

docker-compose exec app bash

Then check the Apache logs:

cat /var/log/apache2/error.log

### Summary

The "403 Forbidden" error is often due to incorrect document root configuration, file permissions, or a missing Apache module. By following the steps outlined above, you should be able to resolve the issue and access your Laravel application successfully. If the problem persists, please provide any error log messages or additional details!

### 1. File System Permissions

Windows file permissions can sometimes interfere with Docker. Ensure that the directory where your Laravel application resides has the correct permissions.

– Right-click the project folder, select **Properties**, then go to the **Security** tab.
– Ensure that your user account has **Full Control** over the directory.
– If using WSL (Windows Subsystem for Linux), make sure that the files are accessible in the WSL environment as well.

### 2. Correct Apache Configuration

Make sure that Apache is correctly configured to serve files from the `public` directory of your Laravel application. As mentioned before, you can create a custom Apache configuration file. If you haven't set it up yet, create a file named `000-default.conf` with the following content:

<VirtualHost *:80>
    DocumentRoot /var/www/html/public

    <Directory /var/www/html/public>
        AllowOverride All
        Require all granted
    </Directory>
</VirtualHost>

Copy this file into your Docker container by adding the following line to your `Dockerfile`:

COPY 000-default.conf /etc/apache2/sites-available/000-default.conf

### 3. Update Your Dockerfile

Make sure your `Dockerfile` includes the necessary commands to enable `mod_rewrite` and set permissions. Here’s a sample Dockerfile:

# Use the official PHP image with Apache
FROM php:8.3-apache

# Install PHP extensions
RUN docker-php-ext-install pdo pdo_mysql

# Enable Apache mod_rewrite
RUN a2enmod rewrite

# Set the working directory
WORKDIR /var/www/html

# Copy application files
COPY --chown=www-data:www-data . /var/www/html

# Set permissions for storage and cache
RUN chown -R www-data:www-data /var/www/html/storage /var/www/html/bootstrap/cache
RUN chmod -R 775 /var/www/html/storage /var/www/html/bootstrap/cache

### 4. Ensure Docker is Running with WSL2

If you are using Docker Desktop on Windows, make sure it's configured to use WSL2 as the backend. This setup can help with filesystem compatibility. You can check this in Docker Desktop settings under **General** > **Use the WSL 2 based engine**.

### 5. Rebuild the Docker Containers

After making changes, rebuild your containers to ensure that everything is applied correctly:

docker-compose down
docker-compose up --build -d

### 6. Check the Laravel Environment

Make sure your `.env` file is set up correctly, and you're not blocking access to the application. The configuration should not restrict access, and you may want to temporarily set the `APP_DEBUG` variable to `true` for more detailed error messages:

APP_DEBUG=true

### 7. Access the Application via `localhost`

Once everything is set up, access your Laravel application via `http://localhost:8080`. If you're still seeing the "403 Forbidden" error, ensure that the Apache logs inside the container provide more context:

docker-compose exec app bash
cat /var/log/apache2/error.log

### 8. Firewall Settings

Sometimes, Windows Firewall can interfere with Docker’s network configuration. Make sure that Docker has permissions through the firewall:

– Go to **Control Panel** > **System and Security** > **Windows Defender Firewall**.
– Click on **Allow an app or feature through Windows Defender Firewall**.
– Ensure that Docker is allowed on both private and public networks.

### Summary

By following these steps, you should be able to resolve the "403 Forbidden" error in your Laravel application running on Docker in Windows 11. If the problem persists, providing error messages from the Apache logs can help diagnose the issue further.

# Install PHP extensions
RUN docker-php-ext-install pdo pdo_mysql

# Enable Apache mod_rewrite
RUN a2enmod rewrite

# Set the working directory
WORKDIR /var/www/html

# Copy existing application directory permissions
COPY –chown=www-data:www-data shareyourthoughts/ /var/www/html

# Set permissions for storage and cache
RUN chown -R www-data:www-data /var/www/html/storage /var/www/html/bootstrap/cache
RUN chmod -R 775 /var/www/html/storage /var/www/html/bootstrap/cache
correct above laravel in shareyourthoughts folder

### Revised Dockerfile

# Use the official PHP image with Apache
FROM php:8.3-apache

# Install required PHP extensions
RUN docker-php-ext-install pdo pdo_mysql

# Enable Apache mod_rewrite
RUN a2enmod rewrite

# Set the working directory
WORKDIR /var/www/html

# Copy existing application directory to the container
COPY --chown=www-data:www-data shareyourthoughts/ /var/www/html/

# Set permissions for storage and bootstrap/cache directories
RUN chown -R www-data:www-data /var/www/html/storage /var/www/html/bootstrap/cache
RUN chmod -R 775 /var/www/html/storage /var/www/html/bootstrap/cache

# Expose port 80
EXPOSE 80

### Key Points in This Dockerfile

1. **Base Image**: It uses the official `php:8.3-apache` image, which has Apache installed with PHP support.

2. **PHP Extensions**: The `pdo` and `pdo_mysql` extensions are installed, which are essential for connecting Laravel to a MySQL database.

3. **Enable mod_rewrite**: This is crucial for Laravel's routing to work correctly.

4. **Working Directory**: The working directory is set to `/var/www/html`, which is the default document root for Apache in this image.

5. **Copying Files**: The `COPY` command is used to copy files from your local `shareyourthoughts` folder into the container. The `–chown=www-data:www-data` flag ensures that the files are owned by the `www-data` user and group, which Apache runs under.

6. **Setting Permissions**: The `RUN` commands set the appropriate permissions on the `storage` and `bootstrap/cache` directories, which Laravel needs to write to.

7. **Expose Port**: Exposes port 80, which is the default port for HTTP traffic. This line is not strictly necessary for the application to work but can be useful for clarity.

### Building the Image

After saving your Dockerfile, navigate to the directory containing your `docker-compose.yml` and run:

docker-compose down
docker-compose up --build -d

This command will stop any running containers, rebuild the images, and start the containers again.

### Additional Considerations

– **Environment Configuration**: Ensure your `.env` file is correctly set up for your local environment, particularly the database connection settings.

– **Firewall Settings**: If you face access issues, ensure that your firewall allows connections through the port you've configured (8080 in your case).

– **Logs for Debugging**: If you still face issues, checking the Apache logs inside the container can provide more context. You can access the container and view logs with:

docker-compose exec app bash
  cat /var/log/apache2/error.log

This revised Dockerfile and the steps should help you set up your Laravel application correctly in Docker. If you encounter any other issues or have further questions, feel free to ask!

IlluminateDatabaseQueryException

SQLSTATE[HY000] [2002] php_network_getaddresses: getaddrinfo for db failed: No such host is known. (Connection: mysql, SQL: select table_name as `name`, (data_length + index_length) as `size`, table_comment as `comment`, engine as `engine`, table_collation as `collation` from information_schema.tables where table_schema = 'laravel' and table_type in ('BASE TABLE', 'SYSTEM VERSIONED') order by table_name)

### 1. Check Your `.env` File

Ensure that the database connection settings in your Laravel project's `.env` file are correctly pointing to the MySQL service defined in your `docker-compose.yml`. The settings should look like this:

DB_CONNECTION=mysql
DB_HOST=db          # This should match the service name in your docker-compose.yml
DB_PORT=3306
DB_DATABASE=laravel
DB_USERNAME=laravel
DB_PASSWORD=password

### 2. Confirm `docker-compose.yml` Configuration

Make sure that the MySQL service in your `docker-compose.yml` file is correctly defined. It should look similar to this:

version: '3.8'

services:
  app:
    build:
      context: .
      dockerfile: Dockerfile
    container_name: laravel_app
    volumes:
      - .:/var/www/html
    networks:
      - laravel_network
    depends_on:
      - db
    ports:
      - "8080:80"

  db:
    image: mysql:8.0
    container_name: laravel_db
    restart: always
    environment:
      MYSQL_DATABASE: laravel
      MYSQL_USER: laravel
      MYSQL_PASSWORD: password
      MYSQL_ROOT_PASSWORD: rootpassword
    volumes:
      - db_data:/var/lib/mysql
    networks:
      - laravel_network

networks:
  laravel_network:
    driver: bridge

volumes:
  db_data:

### 3. Verify Docker Network

Since you are using Docker Compose, all services defined in the same `docker-compose.yml` file are automatically part of the same network. You can check this by running:

docker network ls

Then, inspect the network:

docker network inspect <network_name>

Make sure that both the `laravel_app` (your Laravel app) and `laravel_db` (your MySQL database) containers are listed in the same network.

### 4. Test Connectivity from Laravel Container

You can enter the Laravel container and test if you can ping the MySQL service:

docker-compose exec app bash
ping db

If you can ping `db`, it confirms that the hostname is resolvable. If not, you may have a networking issue.

### 5. Restart Docker Services

Sometimes, restarting the Docker services can resolve connectivity issues. Run:

docker-compose down
docker-compose up -d

### 6. Wait for MySQL to Initialize

If you're starting both containers at the same time, MySQL might not be fully initialized when you run migrations. You can try adding a delay before running migrations, or use a script to wait for the MySQL service to be available.

### 7. Check MySQL Logs

You can check the MySQL logs for any errors that might provide more insight into the issue. Enter the MySQL container:

docker-compose exec db bash
cat /var/log/mysql/error.log

### 8. Verify Credentials

Double-check the credentials in your `.env` file against those set in the `docker-compose.yml`. Ensure they match:

– **DB_DATABASE**: `laravel`
– **DB_USERNAME**: `laravel`
– **DB_PASSWORD**: `password`

### Summary

If you follow these steps and ensure that your settings are correct, you should be able to resolve the connection issue. If the problem persists, please share any specific error messages from the MySQL logs or output from the above checks for further assistance!