GNU/Linux >> Linux Esercitazione >  >> Linux

Come distribuire un'applicazione PHP con Nginx e MySQL utilizzando Docker e Docker Compose

Docker è uno strumento di containerizzazione open source che consente di creare, distribuire ed eseguire applicazioni utilizzando i container. I contenitori consentono di creare un pacchetto di un'applicazione con tutte le parti necessarie e distribuirla come un unico pacchetto. I container sono portatili e puoi distribuirli ovunque. Un container offre agli sviluppatori un ambiente di lavoro uniforme e snello che può essere facilmente condiviso.

In questa guida ti mostreremo come distribuire un'applicazione PHP con Nginx e MySQL usando Docker e Docker Compose.

Prerequisiti

  • Un nuovo server Ubuntu 20.04 sulla piattaforma Atlantic.Net Cloud
  • Una password di root configurata sul tuo server

Fase 1:crea un server cloud Atlantic.Net

Per prima cosa, accedi al tuo server Atlantic.Net Cloud. Crea un nuovo server, scegliendo Ubuntu 20.04 come sistema operativo con almeno 4 GB di RAM. Collegati al tuo Cloud Server tramite SSH e accedi utilizzando le credenziali evidenziate in alto nella pagina.

Dopo aver effettuato l'accesso al tuo server Ubuntu 20.04, esegui il comando seguente per aggiornare il tuo sistema di base con gli ultimi pacchetti disponibili.

apt-get update -y

Passaggio 2:installazione di Docker e Docker Compose

Innanzitutto, installa le dipendenze richieste utilizzando il comando seguente:

apt-get install apt-transport-https ca-certificates curl tree software-properties-common -y

Quindi, aggiungi il repository Docker utilizzando il seguente comando:

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | apt-key add -
add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu focal stable"

Quindi, installa Docker e Docker Compose con il seguente comando:

apt-get install docker-ce docker-compose -y

Una volta terminato, puoi procedere al passaggio successivo.

Fase 3 – Struttura della directory

Ai fini di questo tutorial, utilizzeremo la seguente struttura di directory:

/root/docker-project/
├── docker-compose.yml
├── nginx
│   ├── default.conf
│   └── Dockerfile
├── php
│   └── Dockerfile
└── www
    └── html
        └── index.php

Fase 4:crea un contenitore Nginx

Prima di iniziare, dovrai creare e avviare un contenitore Nginx per ospitare l'applicazione PHP.

Innanzitutto, crea una directory per il tuo progetto con il seguente comando:

mkdir ~/docker-project

Quindi, cambia la directory nel tuo progetto e crea un file docker-compose.yml per avviare il contenitore Nginx.

cd ~/docker-project
nano docker-compose.yml

Aggiungi le seguenti righe:

     nginx:   
      image: nginx:latest  
      container_name: nginx-container  
      ports:   
       - 80:80

Salva e chiudi il file quando hai finito.

Il file sopra scaricherà l'ultima immagine Nginx, creerà un contenitore nginx e lo esporrà sulla porta 80.

Quindi, avvia il contenitore Nginx con il seguente comando:

docker-compose up -d

Puoi controllare il contenitore in esecuzione con il seguente comando:

docker ps

Dovresti vedere il seguente output:

CONTAINER ID   IMAGE          COMMAND                  CREATED         STATUS         PORTS                               NAMES
c6641e4d5bbf   nginx:latest   "/docker-entrypoint.…"   5 seconds ago   Up 3 seconds   0.0.0.0:80->80/tcp, :::80->80/tcp   nginx-container

Ora apri il tuo browser web e accedi al tuo contenitore Nginx utilizzando l'URL http://your-server-ip . Dovresti vedere la pagina di test di Nginx nella schermata seguente:

Fase 5:crea un contenitore PHP

Innanzitutto, crea una nuova directory all'interno del tuo progetto con il seguente comando:

mkdir -p ~/docker-project/www/html

Quindi, crea un file index.php per verificare la tua versione di PHP.

nano ~/docker-project/www/html/index.php

Aggiungi le seguenti righe:

     <!DOCTYPE html>  
     <head>  
      <title>Hello World!</title>
     </head>  

     <body>  
      <h1>Hello World!</h1>
      <p><?php echo 'We are running PHP, version: ' . phpversion(); ?></p>
     </body>

Salva e chiudi il file, quindi crea una directory per Nginx all'interno della directory del tuo progetto:

mkdir ~/docker-project/nginx

Quindi, crea un file di configurazione predefinito Nginx per eseguire la tua applicazione PHP:

nano ~/docker-project/nginx/default.conf

Aggiungi le seguenti righe:

server {  

     listen 80 default_server;  
     root /var/www/html;  
     index index.html index.php;  

     charset utf-8;  

     location / {  
      try_files $uri $uri/ /index.php?$query_string;  
     }  

     location = /favicon.ico { access_log off; log_not_found off; }  
     location = /robots.txt { access_log off; log_not_found off; }  

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

     sendfile off;  

     client_max_body_size 100m;  

     location ~ .php$ {  
      fastcgi_split_path_info ^(.+.php)(/.+)$;  
      fastcgi_pass php:9000;  
      fastcgi_index index.php;  
      include fastcgi_params;  
      fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;  
      fastcgi_intercept_errors off;  
      fastcgi_buffer_size 16k;  
      fastcgi_buffers 4 16k;  
    }  

     location ~ /.ht {  
      deny all;  
     }  
    }

Salva e chiudi il file.

Quindi, crea un Dockerfile all'interno della directory nginx. Questo copierà il file di configurazione predefinito di Nginx nel contenitore Nginx.

nano ~/docker-project/nginx/Dockerfile

Aggiungi le seguenti righe:

    FROM nginx:latest   
    COPY ./default.conf /etc/nginx/conf.d/default.conf

Quindi, modifica il file docker-compose.yml:

nano ~/docker-project/docker-compose.yml

Rimuovi i vecchi contenuti e aggiungi i seguenti contenuti:

---
nginx:
build: ./nginx/
container_name: nginx-container
ports:
- 80:80
links:
- php
volumes:
- ./www/html/:/var/www/html/

php:
immagine:php:7.0-fpm
nome_container:php-container
expose:
– 9000
volumi:
– ./www/html /:/var/www/html/

 

 Salva e chiudi il file quando hai finito.
 

 Il file sopra creerà un nuovo contenitore php, esporrà PHP-FPM sulla porta 9000, collegherà nginx-container a php-container, creerà un volume e lo monterà sul contenitore in modo che tutto il contenuto sia sincronizzato con la directory del contenitore /var/www/html/.
 

 Ora avvia il contenitore con il seguente comando:
 
cd ~/docker-project
docker-compose up -d
 

 Puoi verificare i contenitori in esecuzione con il seguente comando:
 
docker ps
 

 Dovresti vedere il seguente output:
 
CONTAINER ID   IMAGE                  COMMAND                  CREATED          STATUS          PORTS                               NAMES
82c8baf15221   docker-project_nginx   "/docker-entrypoint.…"   23 seconds ago   Up 22 seconds   0.0.0.0:80->80/tcp, :::80->80/tcp   nginx-container
10778c6686d8   php:7.0-fpm            "docker-php-entrypoi…"   25 seconds ago   Up 23 seconds   9000/tcp                            php-container

 

 Ora apri il tuo browser web e accedi all'URL http://your-server-ip . Dovresti vedere la tua pagina Hello World:
 

 
 

 Successivamente, verificheremo se il nostro volume montato funziona o meno. Per farlo, modifica il file index.php:
 
nano ~/docker-project/www/html/index.php
 

 Cambia la riga "Hello World! Le modifiche vengono applicate”:
 
     <!DOCTYPE html>  
     <head>  
      <title>Hello World!</title>
     </head>  

     <body>  
      <h1>Hello World! Changes are Applied</h1>
      <p><?php echo 'We are running PHP, version: ' . phpversion(); ?></p>
     </body>

 

 Ora, aggiorna la tua pagina web. Dovresti vedere la tua pagina modificata sullo schermo:
 

 
 
Fase 6:crea un contenitore di dati
 

 Come puoi vedere, abbiamo montato la directory www/html su entrambi i nostri container, nginx-container e php-container. Tuttavia, questo non è un modo corretto. In questa sezione creeremo un contenitore di dati separato per contenere i dati e lo collegheremo a tutti gli altri contenitori.
 

 Per farlo, modifica il file docker-compose.html:
 
nano ~/docker-project/docker-compose.yml
 

 Apporta le seguenti modifiche:
 
    nginx:    
      build: ./nginx/  
      container_name: nginx-container  
      ports:  
       - 80:80  
      links:  
       - php  
      volumes_from:  
       - app-data  

    php:    
      image: php:7.0-fpm  
      container_name: php-container  
      expose:  
       - 9000  
      volumes_from:  
       - app-data  

    app-data:    
      image: php:7.0-fpm  
      container_name: app-data-container  
      volumes:  
       - ./www/html/:/var/www/html/  
      command: "true"

 

 Ora, ricrea e avvia tutti i container usando il seguente comando:
 
cd ~/docker-project
docker-compose up -d
 

 Ora verifica tutti i container in esecuzione con il seguente comando:
 
docker ps -a
 

 Dovresti vedere il seguente output:
 
CONTAINER ID   IMAGE                  COMMAND                  CREATED          STATUS                      PORTS                               NAMES
849315c7ffc0   docker-project_nginx   "/docker-entrypoint.…"   27 seconds ago   Up 25 seconds               0.0.0.0:80->80/tcp, :::80->80/tcp   nginx-container
59a0d7040fd8   php:7.0-fpm            "docker-php-entrypoi…"   28 seconds ago   Up 27 seconds               9000/tcp                            php-container
fbca95944234   php:7.0-fpm            "docker-php-entrypoi…"   29 seconds ago   Exited (0) 28 seconds ago                                       app-data-container

 
Passaggio 7:crea un contenitore MySQL
 

 In questa sezione creeremo un contenitore di database MySQL e lo collegheremo a tutti gli altri contenitori.
 

 Innanzitutto, dovrai modificare l'immagine PHP e installare l'estensione PHP per MySQL per connetterti al database MySQL.
 

 Innanzitutto, crea una directory per PHP con il seguente comando:
 
mkdir ~/docker-project/php
 

 Quindi, crea un Dockerfile per installare l'estensione PHP:
 
nano ~/docker-project/php/Dockerfile
 

 Aggiungi le seguenti righe:
 
    FROM php:7.0-fpm  
    RUN docker-php-ext-install pdo_mysql 

 

 Salva e chiudi il file. Quindi, modifica il file docker-compose.yml per creare un contenitore MySQL e un contenitore di dati MySQL per contenere il database e le tabelle:
 
nano ~/docker-project/docker-compose.yml
 

 Apporta le seguenti modifiche:
 
     nginx:    
      build: ./nginx/  
      container_name: nginx-container  
      ports:  
       - 80:80  
      links:  
       - php  
      volumes_from:  
       - app-data  

     php:    
      build: ./php/  
      container_name: php-container  
      expose:  
       - 9000  
      links:  
       - mysql  
      volumes_from:  
       - app-data  

     app-data:    
      image: php:7.0-fpm  
      container_name: app-data-container  
      volumes:  
       - ./www/html/:/var/www/html/  
      command: "true"  

     mysql:    
      image: mysql:5.7  
      container_name: mysql-container  
      volumes_from:  
       - mysql-data  
      environment:  
       MYSQL_ROOT_PASSWORD: secret  
       MYSQL_DATABASE: mydb  
       MYSQL_USER: myuser  
       MYSQL_PASSWORD: password  

     mysql-data:    
      image: mysql:5.7  
      container_name: mysql-data-container  
      volumes:  
       - /var/lib/mysql  
      command: "true" 

 

 Salva e chiudi il file.
 

 Quindi, modifica il  index.php file e apportare alcune modifiche per testare la connessione al database.
 
nano ~/docker-project/www/html/index.php
 

 Apporta le seguenti modifiche:
 
     <!DOCTYPE html>  
     <head>  
      <title>Hello World!</title>
     </head>   

     <body>  
      <h1>Hello World!</h1>  
      <p><?php echo 'We are running PHP, version: ' . phpversion(); ?></p>  
      <?  
       $database ="mydb";  
       $user = "myuser";  
       $password = "password";  
       $host = "mysql";  

       $connection = new PDO("mysql:host={$host};dbname={$database};charset=utf8", $user, $password);  
       $query = $connection->query("SELECT TABLE_NAME FROM information_schema.TABLES WHERE TABLE_TYPE='BASE TABLE'");  
       $tables = $query->fetchAll(PDO::FETCH_COLUMN);  

        if (empty($tables)) {
          echo "<p>There are no tables in database \"{$database}\".</p>";
        } else {
          echo "<p>Database \"{$database}\" has the following tables:</p>";
          echo "<ul>";
            foreach ($tables as $table) {
              echo "<li>{$table}</li>";
            }
          echo "</ul>";
        }
        ?>
    </body>
</html>

 

 Salva e chiudi il file, quindi avvia il contenitore con il seguente comando:
 
cd ~/docker-project
docker-compose up -d
 

 Verifica tutti i container in esecuzione con il comando seguente:
 
docker ps -a
 

 Dovresti vedere il seguente output:
 
CONTAINER ID   IMAGE                  COMMAND                  CREATED          STATUS                      PORTS                               NAMES
d3e82747fe0d   mysql:5.7              "docker-entrypoint.s…"   39 seconds ago   Up 38 seconds               3306/tcp, 33060/tcp                 mysql-container
606320e5a7f8   mysql:5.7              "docker-entrypoint.s…"   41 seconds ago   Exited (0) 39 seconds ago                                       mysql-data-container
ca4f63797d11   docker-project_php     "docker-php-entrypoi…"   2 hours ago      Up 2 hours                  9000/tcp                            php-container
849315c7ffc0   docker-project_nginx   "/docker-entrypoint.…"   2 hours ago      Up 2 hours                  0.0.0.0:80->80/tcp, :::80->80/tcp   nginx-container
fbca95944234   php:7.0-fpm            "docker-php-entrypoi…"   2 hours ago      Exited (0) 39 seconds ago                                       app-data-container

 
Fase 8:verifica della connessione al database
 

 Ora apri il tuo browser web e accedi alla pagina web all'indirizzo http://your-server-ip . Dovresti vedere la seguente schermata:
 

 
 

 Come puoi vedere, non ci sono tabelle nel database di mydb.
 

 Tuttavia, ci sono in effetti alcune tabelle, ma quelle non sono visibili da un utente normale. Se vuoi vederli, modifica il file index.php e cambia  $user a "root" e $password a "segreto" 
 
nano ~/docker-project/www/html/index.php
 

 Modifica la seguente riga:
 
       $user = "root";  
       $password = "secret";  

 

 Salva e chiudi il file, quindi aggiorna la pagina. Dovresti vedere il database con tutte le tabelle nella schermata seguente:
 

 
 
Conclusione
 

 Nella guida sopra, hai imparato come distribuire un'applicazione PHP con Nginx e MySQL usando Docker e Docker Compose. Ora dovresti essere in grado di ospitare l'applicazione PHP nell'ambiente di produzione con Docker; provalo sul tuo account di hosting VPS da Atlantic.Net.
 



            


        


        

            

                
                        
            

            
            

                   
                
            

         


         

            
         

            

    



    

        
        


            

                Linux
                
            


            
    
                              
		
  1. 
                    
                    
                        
    
                          Come distribuire e gestire MongoDB con Docker 
                        
    
                        
                
    2. 

  2. 
                    
                    
                        
    
                          Come distribuire le applicazioni Node.js con pm2 e Nginx su Ubuntu 
                        
    
                        
                
    3. 

  3. 
                    
                    
                        
    
                          Come distribuire microservizi con Docker 
                        
    
                        
                
    4. 

  4. 
                    
                    
                        
    
                          Come distribuire un container nginx con Docker su Linode 
                        
    
                        
                
    5. 

  5. 
                    
                    
                        
    
                          Come distribuire l'applicazione Flask con Nginx e Gunicorn su Ubuntu 20.04 
                        
    
                        
                
    6. 


            


        



        


            

    
                

    
                    
                        
                        

                            

                               Come installare e configurare Laravel con Docker Compose su Ubuntu 20.04 
                            

                        

                    
    
                
  

    
                    
                        
                        

                            

                               Come installare Linux, Nginx, MariaDB e PHP (LEMP) su Fedora 22 
                            

                        

                    
    
                
  

    
                    
                        
                        

                            

                               Come installare Nginx, MySQL e PHP (LEMP) su un server Ubuntu 15.04 
                            

                        

                    
    
                
  

    
                    
                        
                        

                            

                               Come connettersi a MySQL usando PHP 
                            

                        

                    
    
                
  

    
                    
                        
                        

                            

                               Come distribuire l'applicazione Laravel con Nginx su Ubuntu? 
                            

                        

                    
    
                
  

    
                    
                        
                        

                            

                               Come abilitare la memorizzazione nella cache FastCGI lato server con Nginx e PHP