Dockerizzazione dello stack LEMP con Docker-Compose su Ubuntu

Docker-Componi è uno strumento a riga di comando per la definizione e la gestione di applicazioni docker multi-container. Compose è uno script Python, può essere installato facilmente con il comando pip (pip è il comando per installare il software Python dal repository del pacchetto Python). Con compose, possiamo eseguire più contenitori docker con un singolo comando. Ti consente di creare un container come servizio, ottimo per il tuo ambiente di sviluppo, test e staging.

In questo tutorial, ti guiderò passo dopo passo a utilizzare docker-compose per creare un ambiente LEMP Stack (LEMP =Linux - Nginx - MySQL - PHP). Eseguiremo tutti i componenti in diversi contenitori Docker, configureremo un contenitore Nginx, un contenitore PHP, un contenitore PHPMyAdmin e un contenitore MySQL/MariaDB.

Prerequisiti

• Server Ubuntu 16.04 -64 bit
• Privilegi di root

Passaggio 1:installa Docker

In questo passaggio, installeremo Docker. Docker è disponibile nel repository di Ubuntu, basta aggiornare il repository e quindi installarlo.

Aggiorna il repository Ubuntu e aggiorna:

sudo apt-get update
sudo apt-get upgrade

Installa l'ultimo Docker dal repository di Ubuntu.

sudo apt-get install -y docker.io

Avvia la finestra mobile e abilita l'avvio all'avvio:

systemctl start docker
systemctl enable docker

I servizi Docker sono in esecuzione.

Successivamente, puoi provare a utilizzare la finestra mobile con il comando seguente per testarlo:

docker run hello-world

Ciao mondo dalla finestra mobile.

Passaggio 2:installazione di Docker-Compose

Nel primo passaggio, abbiamo già installato Docker. Ora installeremo docker-compose.

Abbiamo bisogno di python-pip per l'installazione di Compose, installa python e python-pip con apt:

sudo apt-get install -y python python-pip

Al termine dell'installazione, installa docker-compose con il comando pip.

pip install docker-compose

Ora controlla la versione di composizione mobile:

docker-compose --version

Docker-compose è stato installato.

Passaggio 3:creare e configurare l'ambiente Docker

In questo passaggio, creeremo il nostro ambiente di composizione mobile. Useremo un utente non root, quindi dobbiamo creare quell'utente ora.

Aggiungi un nuovo utente chiamato 'hakase ' (scegli qui il tuo nome utente se lo desideri):

useradd -m -s /bin/bash hakase
passwd hakase

Successivamente, aggiungi il nuovo utente alla 'docker ' raggruppa e riavvia la finestra mobile.

usermod -a -G docker hakase
sudo systemctl restart docker

Ora l'utente 'hakase ' può usare la finestra mobile senza sudo.

Quindi, dall'utente root, accedi all'utente 'hakase' con su.

su - hakase

Crea una nuova directory per l'ambiente di composizione.

mkdir lemp-compose/
cd lemp-compose/

Questo è il nostro ambiente di composizione Docker, tutti i file che devono essere nel contenitore Docker devono trovarsi in questa directory. Quando utilizziamo docker-compose, abbiamo bisogno di un file .yml denominato 'docker-compose.yml '.

Nella directory 'lemp-compose', crea alcune nuove directory e un file docker-compose.yml:

touch docker-compose.yml
mkdir -p {logs,nginx,public,db-data}

• registri :Directory per i file di registro Nginx.
• nginx :contiene la configurazione di Nginx come host virtuale ecc.
• pubblico :directory per file Web, index.html e file di informazioni PHP.
• db-dati :volume della directory dei dati di MariaDB.

Crea i file di registro error.log e access.log nei 'log ' directory.

touch logs/{error,access}.log

Crea un nuovo file di configurazione dell'host virtuale nginx in 'nginx ' directory:

vim nginx/app.conf

Incolla la configurazione di seguito:

upstream php {
        server phpfpm:9000;
}
 
server {
 
        server_name 193.70.36.50;
 
        error_log "/opt/bitnami/nginx/logs/myapp-error.log";
        access_log  "/opt/bitnami/nginx/logs/myapp-access.log";
 
        root /myapps;
        index index.php index.html;
 
        location / {
 
                try_files $uri $uri/ /index.php?$args;
        }
 
        location ~ \.php$ {
 
                include fastcgi.conf;
                fastcgi_intercept_errors on;
                fastcgi_pass php;
        }
 
        location ~* \.(js|css|png|jpg|jpeg|gif|ico)$ {
                expires max;
                log_not_found off;
        }
}

Salva il file ed esci da vim.

Crea un nuovo file index.html e un file di informazioni PHP in 'pubblico ' directory.

echo '<h1>LEMP Docker-Compose</h1><p><b>hakase-labs</b>' > public/index.html
echo '<?php phpinfo(); ?>' > public/info.php

Ora puoi vedere la directory dell'ambiente come mostrato di seguito:

tree

Fase 4 - Configurazione del file docker-compose.yml

Nel passaggio precedente, abbiamo creato le directory e i file necessari per i nostri contenitori. In questo passaggio, vogliamo modificare il file 'docker-compose.yml '. Nel file docker-compose.yml definiremo i nostri servizi per lo stack LEMP, le immagini di base per ogni container e i volumi docker.

Accedi a 'hakase ' utente e modifica docker-compose.yml file con vim:

su - hakase
cd lemp-compose/
vim docker-compose.yml

- Definisci i servizi Nginx

Incolla la configurazione nginx di seguito:

nginx:
    image: 'bitnami/nginx'
    ports:
        - '80:80'
    links:
        - phpfpm
    volumes:
        - ./logs/access.log:/opt/bitnami/nginx/logs/myapp-access.log
        - ./logs/error.log:/opt/bitnami/nginx/logs/myapp-error.log
        - ./nginx/app.conf:/bitnami/nginx/conf/vhosts/app.conf
        - ./public:/myapps

In quella configurazione, abbiamo già definito:

• nginx :nome dei servizi
• immagine :stiamo usando 'bitnami/nginx ' immagini della finestra mobile
• porte :espone la porta container 80 alla porta host 80
• collegamenti :link 'nginx ' contenitore del servizio in 'phpfpm ' contenitore
• volumi :monta le directory locali nel container. Montare la directory dei file di log, montare la configurazione dell'host virtuale Nginx e montare la directory radice web.

- Definisci servizi PHP-fpm

Incolla la configurazione sotto il blocco Nginx:

phpfpm:
    image: 'bitnami/php-fpm'
    ports:
        - '9000:9000'
    volumes:
        - ./public:/myapps

Abbiamo definito qui:

• phpfpm :definisce il nome del servizio.
• immagine :definisci l'immagine di base per il servizio phpfpm con 'bitnami/php-fpm ' immagine.
• porte :Stiamo eseguendo PHP-fpm con la porta TCP 9000 ed esporre il porto 9000 all'ospite.
• volumi :monta la directory principale web 'pubblica ' a 'le mieapp ' sul contenitore.
  

- Definisci il servizio MySQL

Nel terzo blocco, incolla la configurazione seguente per il contenitore del servizio MariaDB:

mysql:
    image: 'mariadb'
    ports:
        - '3306:3306'
    volumes:
        - ./db-data:/var/lib/mysql
    environment:
        - MYSQL_ROOT_PASSWORD=hakase-labs123

Qui puoi vedere che stiamo usando:

• mysql :come nome del servizio.
• immagine :il contenitore è basato su 'mariadb ' immagini della finestra mobile.
• porte :container di servizio che utilizza la porta 3306 per la connessione MySQL ed esporlo all'host sulla porta 3306 .
• volumi :db-dati directory mysql
• ambiente :imposta la variabile d'ambiente 'MYSQL_ROOT_PASSWORD ' per la password di root mysql per le immagini della finestra mobile, eseguita durante la creazione del contenitore.

- Configurazione dei servizi PHPMyAdmin

L'ultimo blocco, incolla la configurazione di seguito:

phpmyadmin:
    image: 'phpmyadmin/phpmyadmin'
    restart: always
    ports:
       - '8080:80'
    links:
        - mysql:mysql
    environment:
        MYSQL_USERNAME: root
        MYSQL_ROOT_PASSWORD: hakase-labs123
        PMA_HOST: mysql

Stiamo utilizzando un'immagine della finestra mobile 'phpmyadmin', mappando la porta del contenitore 80 a 8080 sull'host, collega il contenitore a mariadb container, imposta riavvia sempre e imposta alcune variabili di ambiente dell'immagine docker, incluso set 'PMA_HOST '.

Salva il file ed esci da vim.

Puoi vedere l'esempio completo su github.

Passaggio 5:esegui Docker-Compose

Ora siamo pronti per eseguire docker-compose. Nota:quando vuoi eseguire docker-compose, devi trovarti nella directory del progetto docker-compose e assicurarti che sia presente il file yml con la configurazione di compose.

Esegui il comando seguente per aumentare lo stack LEMP:

docker-compose up -d

-d: in esecuzione come demone o in background

Vedrai il risultato che i nuovi contenitori sono stati creati, verificalo con il comando seguente:

docker-compose ps

Ora abbiamo quattro container che eseguono Nginx, PHP-fpm, MariaDB e PHPMyAdmin.

Fase 6 - Test

Verifica delle porte utilizzate dal proxy docker sull'host.

netstat -plntu

Possiamo vedere la porta 80 per il container Nginx, la porta 3306 per il container MariaDB, la porta 9000 per il container php-fpm e la porta 8080 per il container PHPMyAdmin.

Accedi alla porta 80 dal browser web e vedrai il nostro file index.html.

http://indirizzo-serverip/

Assicurati che PHP-fpm sia in esecuzione, accedilo dal browser web.

http://indirizzo-serverip/info.php

Accedi al contenitore MySQL nella shell MySQL.

docker-compose exec mysql bash
mysql -u root -p
TYPE MYSQL PASSWORD: hakase-labs123

Ora crea un nuovo database:

create database hakase_db;
exit

Il contenitore della shell mysql di MariaDB è accessibile e abbiamo creato un nuovo database 'hakase_db '.

Quindi, accedi a PHPMyAdmin sulla porta 8080:http://indirizzo-serverip:8080/.

Vedrai la pagina di accesso di PHPMyAdmin, digita semplicemente il nome utente 'root ' e la password è 'hakase-labs123 '.

Verrai automaticamente connesso al contenitore mysql che è stato definito nel PMA_HOST variabile di ambiente.

Fai clic su "Vai ' e vedrai la dashboard di phpmyadmin collegata a 'mysql ' contenitore.

Successo! Lo stack LEMP è in esecuzione con una configurazione di composizione mobile, composta da quattro contenitori.

Riferimento

https://hub.docker.com/r/bitnami/nginx/

https://hub.docker.com/r/bitnami/php-fpm/

https://hub.docker.com/_/mariadb/

https://hub.docker.com/r/phpmyadmin/phpmyadmin/

https://docs.docker.com/compose/

https://github.com/yuzukiseo/hakase-labs/tree/master/lamp-compose