# Docker nginx php mysql

## Docker nginx php mysql

<https://github.com/nanoninja/docker-nginx-php-mysql>

[docker-nginx-php-mysql](https://gitlab.com/johnmkane/tech-recipe-book/-/blob/main/Book/Web%20Dev/Docker%20nginx%20php%20mysql/Docker%20nginx%20php%20mysql/docker-nginx-php-mysql/README.md)

## [Nginx PHP MySQL](https://github.com/nanoninja/docker-nginx-php-mysql#nginx-php-mysql--)

Docker running Nginx, PHP-FPM, Composer, MySQL and PHPMyAdmin.

### [Overview](https://github.com/nanoninja/docker-nginx-php-mysql#overview)

1. [Install prerequisites](https://github.com/nanoninja/docker-nginx-php-mysql#install-prerequisites)

   Before installing project make sure the following prerequisites have been met.
2. [Clone the project](https://github.com/nanoninja/docker-nginx-php-mysql#clone-the-project)

   We’ll download the code from its repository on GitHub.
3. [Configure Nginx With SSL Certificates](https://github.com/nanoninja/docker-nginx-php-mysql#configure-nginx-with-ssl-certificates) \[`Optional`]

   We'll generate and configure SSL certificate for nginx before running server.
4. [Configure Xdebug](https://github.com/nanoninja/docker-nginx-php-mysql#configure-xdebug) \[`Optional`]

   We'll configure Xdebug for IDE (PHPStorm or Netbeans).
5. [Run the application](https://github.com/nanoninja/docker-nginx-php-mysql#run-the-application)

   By this point we’ll have all the project pieces in place.
6. [Use Makefile](https://github.com/nanoninja/docker-nginx-php-mysql#use-makefile) \[`Optional`]

   When developing, you can use `Makefile` for doing recurrent operations.
7. [Use Docker Commands](https://github.com/nanoninja/docker-nginx-php-mysql#use-docker-commands)

   When running, you can use docker commands for doing recurrent operations.

### [Install prerequisites](https://github.com/nanoninja/docker-nginx-php-mysql#install-prerequisites)

To run the docker commands without using **sudo** you must add the **docker** group to **your-user**:

```
sudo usermod -aG docker your-user

```

For now, this project has been mainly created for Unix `(Linux/MacOS)`. Perhaps it could work on Windows.

All requisites should be available for your distribution. The most important are :

* [Git](https://git-scm.com/downloads)
* [Docker](https://docs.docker.com/engine/installation/)
* [Docker Compose](https://docs.docker.com/compose/install/)

Check if `docker-compose` is already installed by entering the following command :

```
which docker-compose
```

Check Docker Compose compatibility :

* [Compose file version 3 reference](https://docs.docker.com/compose/compose-file/)

The following is optional but makes life more enjoyable :

```
which make
```

On Ubuntu and Debian these are available in the meta-package build-essential. On other distributions, you may need to install the GNU C++ compiler separately.

```
sudo apt install build-essential
```

#### [Images to use](https://github.com/nanoninja/docker-nginx-php-mysql#images-to-use)

* [Nginx](https://hub.docker.com/_/nginx/)
* [MySQL](https://hub.docker.com/_/mysql/)
* [PHP-FPM](https://hub.docker.com/r/nanoninja/php-fpm/)
* [Composer](https://hub.docker.com/_/composer/)
* [PHPMyAdmin](https://hub.docker.com/r/phpmyadmin/phpmyadmin/)
* [Generate Certificate](https://hub.docker.com/r/jacoelho/generate-certificate/)

You should be careful when installing third party web servers such as MySQL or Nginx.

This project use the following ports :

| Server     | Port |
| ---------- | ---- |
| MySQL      | 8989 |
| PHPMyAdmin | 8080 |
| Nginx      | 8000 |
| Nginx SSL  | 3000 |

### [Clone the project](https://github.com/nanoninja/docker-nginx-php-mysql#clone-the-project)

To install [Git](http://git-scm.com/book/en/v2/Getting-Started-Installing-Git), download it and install following the instructions :

```
git clone https://github.com/nanoninja/docker-nginx-php-mysql.git
```

Go to the project directory :

```
cd docker-nginx-php-mysql
```

#### [Project tree](https://github.com/nanoninja/docker-nginx-php-mysql#project-tree)

```
.
├── Makefile
├── README.md
├── data
│   └── db
│       ├── dumps
│       └── mysql
├── doc
├── docker-compose.yml
├── etc
│   ├── nginx
│   │   ├── default.conf
│   │   └── default.template.conf
│   ├── php
│   │   └── php.ini
│   └── ssl
└── web
    ├── app
    │   ├── composer.json.dist
    │   ├── phpunit.xml.dist
    │   ├── src
    │   │   └── Foo.php
    │   └── test
    │       ├── FooTest.php
    │       └── bootstrap.php
    └── public
        └── index.php
```

### [Configure Nginx With SSL Certificates](https://github.com/nanoninja/docker-nginx-php-mysql#configure-nginx-with-ssl-certificates)

You can change the host name by editing the `.env` file.

If you modify the host name, do not forget to add it to the `/etc/hosts` file.

1.

```
Generate SSL certificates
```

````
```
source .env && docker run --rm -v $(pwd)/etc/ssl:/certificates -e "SERVER=$NGINX_HOST" jacoelho/generate-certificate
```
````

2\. Configure Nginx

````
Do not modify the `etc/nginx/default.conf` file, it is overwritten by `etc/nginx/default.template.conf`

Edit nginx file `etc/nginx/default.template.conf` and uncomment the SSL server section :

```
# server {
#     server_name ${NGINX_HOST};
#
#     listen 443 ssl;
#     fastcgi_param HTTPS on;
#     ...
# }
```
````

### [Configure Xdebug](https://github.com/nanoninja/docker-nginx-php-mysql#configure-xdebug)

If you use another IDE than [PHPStorm](https://www.jetbrains.com/phpstorm/) or [Netbeans](https://netbeans.org/), go to the [remote debugging](https://xdebug.org/docs/remote) section of Xdebug documentation.

For a better integration of Docker to PHPStorm, use the [documentation](https://gitlab.com/johnmkane/tech-recipe-book/-/blob/main/Book/Web%20Dev/Docker%20nginx%20php%20mysql/phpstorm-macosx/README.md).

1.

```
Get your own local IP address :
```

````
```
sudo ifconfig
```
````

2\. Edit php file `etc/php/php.ini` and comment or uncomment the configuration as needed. 3.

````
Set the `remote_host` parameter with your IP :

```
xdebug.remote_host=192.168.0.1 # your IP
```
````

### [Run the application](https://github.com/nanoninja/docker-nginx-php-mysql#run-the-application)

1.

```
Copying the composer configuration file :
```

````
```
cp web/app/composer.json.dist web/app/composer.json
```
````

2\. Start the application :

````
```
docker-compose up -d
```

**Please wait this might take a several minutes...**

```
docker-compose logs -f # Follow log output
```
````

3\.

```
Open your favorite browser :

- [http://localhost:8000](http://localhost:8000/)
- [https://localhost:3000](https://localhost:3000/) ([HTTPS](https://github.com/nanoninja/docker-nginx-php-mysql#configure-nginx-with-ssl-certificates) not configured by default)
- [http://localhost:8080](http://localhost:8080/) PHPMyAdmin (username: dev, password: dev)
```

4\.

````
Stop and clear services

```
docker-compose down -v
```
````

### [Use Makefile](https://github.com/nanoninja/docker-nginx-php-mysql#use-makefile)

When developing, you can use [Makefile](https://en.wikipedia.org/wiki/Make_\(software\)) for doing the following operations :

| Name          | Description                                |
| ------------- | ------------------------------------------ |
| apidoc        | Generate documentation of API              |
| clean         | Clean directories for reset                |
| code-sniff    | Check the API with PHP Code Sniffer (PSR2) |
| composer-up   | Update PHP dependencies with composer      |
| docker-start  | Create and start containers                |
| docker-stop   | Stop and clear all services                |
| gen-certs     | Generate SSL certificates for nginx        |
| logs          | Follow log output                          |
| mysql-dump    | Create backup of all databases             |
| mysql-restore | Restore backup of all databases            |
| phpmd         | Analyse the API with PHP Mess Detector     |
| test          | Test application with phpunit              |

#### [Examples](https://github.com/nanoninja/docker-nginx-php-mysql#examples)

Start the application :

```
make docker-start
```

Show help :

```
make help
```

### [Use Docker commands](https://github.com/nanoninja/docker-nginx-php-mysql#use-docker-commands)

#### [Installing package with composer](https://github.com/nanoninja/docker-nginx-php-mysql#installing-package-with-composer)

```
docker run --rm -v $(pwd)/web/app:/app composer require symfony/yaml
```

#### [Updating PHP dependencies with composer](https://github.com/nanoninja/docker-nginx-php-mysql#updating-php-dependencies-with-composer)

```
docker run --rm -v $(pwd)/web/app:/app composer update
```

#### [Generating PHP API documentation](https://github.com/nanoninja/docker-nginx-php-mysql#generating-php-api-documentation)

```
docker run --rm -v $(pwd):/data phpdoc/phpdoc -i=vendor/ -d /data/web/app/src -t /data/web/app/doc
```

#### [Testing PHP application with PHPUnit](https://github.com/nanoninja/docker-nginx-php-mysql#testing-php-application-with-phpunit)

```
docker-compose exec -T php ./app/vendor/bin/phpunit --colors=always --configuration ./app
```

#### [Fixing standard code with](https://github.com/nanoninja/docker-nginx-php-mysql#fixing-standard-code-with-psr2) [PSR2](http://www.php-fig.org/psr/psr-2/)

```
docker-compose exec -T php ./app/vendor/bin/phpcbf -v --standard=PSR2 ./app/src
```

#### [Checking the standard code with](https://github.com/nanoninja/docker-nginx-php-mysql#checking-the-standard-code-with-psr2) [PSR2](http://www.php-fig.org/psr/psr-2/)

```
docker-compose exec -T php ./app/vendor/bin/phpcs -v --standard=PSR2 ./app/src
```

#### [Analyzing source code with](https://github.com/nanoninja/docker-nginx-php-mysql#analyzing-source-code-with-php-mess-detector) [PHP Mess Detector](https://phpmd.org/)

```
docker-compose exec -T php ./app/vendor/bin/phpmd ./app/src text cleancode,codesize,controversial,design,naming,unusedcode
```

#### [Checking installed PHP extensions](https://github.com/nanoninja/docker-nginx-php-mysql#checking-installed-php-extensions)

```
docker-compose exec php php -m
```

#### [Handling database](https://github.com/nanoninja/docker-nginx-php-mysql#handling-database)

#### [MySQL shell access](https://github.com/nanoninja/docker-nginx-php-mysql#mysql-shell-access)

```
docker exec -it mysql bash
```

and

```
mysql -u"$MYSQL_ROOT_USER" -p"$MYSQL_ROOT_PASSWORD"
```

#### [Creating a backup of all databases](https://github.com/nanoninja/docker-nginx-php-mysql#creating-a-backup-of-all-databases)

```
mkdir -p data/db/dumps
```

```
source .env && docker exec $(docker-compose ps -q mysqldb) mysqldump --all-databases -u"$MYSQL_ROOT_USER" -p"$MYSQL_ROOT_PASSWORD" > "data/db/dumps/db.sql"
```

#### [Restoring a backup of all databases](https://github.com/nanoninja/docker-nginx-php-mysql#restoring-a-backup-of-all-databases)

```
source .env && docker exec -i $(docker-compose ps -q mysqldb) mysql -u"$MYSQL_ROOT_USER" -p"$MYSQL_ROOT_PASSWORD" < "data/db/dumps/db.sql"
```

#### [Creating a backup of single database](https://github.com/nanoninja/docker-nginx-php-mysql#creating-a-backup-of-single-database)

**`Notice:`** Replace "YOUR\_DB\_NAME" by your custom name.

```
source .env && docker exec $(docker-compose ps -q mysqldb) mysqldump -u"$MYSQL_ROOT_USER" -p"$MYSQL_ROOT_PASSWORD" --databases YOUR_DB_NAME > "data/db/dumps/YOUR_DB_NAME_dump.sql"
```

#### [Restoring a backup of single database](https://github.com/nanoninja/docker-nginx-php-mysql#restoring-a-backup-of-single-database)

```
source .env && docker exec -i $(docker-compose ps -q mysqldb) mysql -u"$MYSQL_ROOT_USER" -p"$MYSQL_ROOT_PASSWORD" < "data/db/dumps/YOUR_DB_NAME_dump.sql"
```

#### [Connecting MySQL from](https://github.com/nanoninja/docker-nginx-php-mysql#connecting-mysql-from-pdo) [PDO](http://php.net/manual/en/book.pdo.php)

```
<?php
    try {
        $dsn = 'mysql:host=mysql;dbname=test;charset=utf8;port=3306';
        $pdo = new PDO($dsn, 'dev', 'dev');
    } catch (PDOException $e) {
        echo $e->getMessage();
    }
?>
```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://book.konstantinsecurity.com/readme/web-dev/docker-nginx-php-mysql.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.