Docker-Compose es una herramienta de línea de comandos para definir y administrar aplicaciones docker de varios contenedores. Compose es un script de python, se puede instalar fácilmente con el comando pip (pip es el comando para instalar el software de Python desde el repositorio de paquetes de python). Con componer, podemos ejecutar múltiples contenedores docker con un solo comando. Le permite crear un contenedor como servicio, excelente para su entorno de desarrollo, prueba y preparación.
En este tutorial, lo guiaré paso a paso para usar docker-compose para crear un entorno LEMP Stack (LEMP =Linux - Nginx - MySQL - PHP). Ejecutaremos todos los componentes en diferentes contenedores Docker, configuraremos un contenedor Nginx, un contenedor PHP, un contenedor PHPMyAdmin y un contenedor MySQL/MariaDB.
Requisitos previos
- Servidor Ubuntu 16.04 -64 bits
- Privilegios de raíz
Paso 1:instalar Docker
En este paso, instalaremos Docker. Docker está disponible en el repositorio de Ubuntu, simplemente actualice su repositorio y luego instálelo.
Actualice el repositorio de ubuntu y actualice:
sudo apt-get update
sudo apt-get upgrade
Instale la última versión de Docker desde el repositorio de ubuntu.
sudo apt-get install -y docker.io
Inicie Docker y habilítelo para que se inicie en el momento del arranque:
systemctl start docker
systemctl enable docker
Los servicios de Docker se están ejecutando.
A continuación, puede intentar usar la ventana acoplable con el siguiente comando para probarlo:
docker run hello-world
Hola mundo desde docker.
Paso 2:instalar Docker-Compose
En el primer paso, ya instalamos Docker. Ahora instalaremos docker-compose.
Necesitamos python-pip para la instalación de composición, instale python y python-pip con apt:
sudo apt-get install -y python python-pip
Cuando finalice la instalación, instale docker-compose con el comando pip.
pip install docker-compose
Ahora verifique la versión de docker-compose:
docker-compose --version
Se ha instalado Docker-compose.
Paso 3:crear y configurar el entorno Docker
En este paso, construiremos nuestro entorno docker-compose. Usaremos un usuario no root, por lo que debemos crear ese usuario ahora.
Agregue un nuevo usuario llamado 'hakase ' (elija su propio nombre de usuario aquí si lo desea):
useradd -m -s /bin/bash hakase
passwd hakase
A continuación, agregue el nuevo usuario a la 'docker ' grupo y reinicie la ventana acoplable.
usermod -a -G docker hakase
sudo systemctl restart docker
Ahora el usuario 'hakase ' puede usar la ventana acoplable sin sudo.
A continuación, desde el usuario raíz, inicie sesión en el usuario 'hakase' con su.
su - hakase
Cree un nuevo directorio para el entorno de redacción.
mkdir lemp-compose/
cd lemp-compose/
Este es nuestro entorno docker-compose, todos los archivos que estarán en el contenedor Docker deben estar en este directorio. Cuando usamos docker-compose, necesitamos un archivo .yml llamado 'docker-compose.yml '.
En el directorio 'lemp-compose', cree algunos directorios nuevos y un archivo docker-compose.yml:
touch docker-compose.yml
mkdir -p {logs,nginx,public,db-data}
- registros :Directorio de archivos de registro de Nginx.
- nginx :contiene la configuración de Nginx como host virtual, etc.
- público :directorio de archivos web, index.html y archivo de información de PHP.
- datos de base de datos :Volumen del directorio de datos de MariaDB.
Cree los archivos de registro error.log y access.log en 'logs ' directorio.
touch logs/{error,access}.log Cree un nuevo archivo de configuración de host virtual nginx en 'nginx ' directorio:
vim nginx/app.conf
Pegue la configuración a continuación:
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;
}
} Guarde el archivo y salga de vim.
Cree un nuevo archivo index.html y un archivo de información de PHP en 'público ' directorio.
echo '<h1>LEMP Docker-Compose</h1><p><b>hakase-labs</b>' > public/index.html
echo '<?php phpinfo(); ?>' > public/info.php
Ahora puede ver el directorio del entorno como se muestra a continuación:
tree
Paso 4 - Configuración del archivo docker-compose.yml
En el paso anterior, creamos los directorios y archivos necesarios para nuestros contenedores. En este paso, queremos editar el archivo 'docker-compose.yml '. En el archivo docker-compose.yml, definiremos nuestros servicios para la pila LEMP, las imágenes base para cada contenedor y los volúmenes de la ventana acoplable.
Inicie sesión en el 'hakase ' usuario y edite docker-compose.yml archivo con vim:
su - hakase
cd lemp-compose/
vim docker-compose.yml
- Definir los servicios de Nginx
Pegue la configuración de nginx a continuación:
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
En esa configuración, ya hemos definido:
- nginx :nombre de servicios
- imagen :estamos usando 'bitnami/nginx 'imágenes acoplables
- puertos :exponer el puerto del contenedor 80 al puerto anfitrión 80
- enlaces :enlaces 'nginx ' contenedor de servicio a 'phpfpm ' contenedor
- volúmenes :montar directorios locales en el contenedor. Monte el directorio de archivos de registros, monte la configuración del host virtual Nginx y monte el directorio raíz web.
- Definir servicios PHP-fpm
Pegue la configuración debajo del bloque Nginx:
phpfpm:
image: 'bitnami/php-fpm'
ports:
- '9000:9000'
volumes:
- ./public:/myapps
Definimos aquí:
- phpfpm :define el nombre del servicio.
- imagen :defina la imagen base para el servicio phpfpm con 'bitnami/php-fpm ' imagen.
- puertos :Estamos ejecutando PHP-fpm con puerto TCP 9000 y exponiendo el puerto 9000 al anfitrión.
- volúmenes :monte el directorio raíz web 'público ' a 'misaplicaciones ' en el contenedor.
- Definir el servicio MySQL
En el tercer bloque, pegue la siguiente configuración para el contenedor de servicios de MariaDB:
mysql:
image: 'mariadb'
ports:
- '3306:3306'
volumes:
- ./db-data:/var/lib/mysql
environment:
- MYSQL_ROOT_PASSWORD=hakase-labs123
Aquí puedes ver que estamos usando:
- mysql :como el nombre del servicio.
- imagen :el contenedor se basa en 'mariadb ' imágenes acoplables.
- puertos :contenedor de servicio usando el puerto 3306 para la conexión MySQL y exponerlo al host en el puerto 3306 .
- volúmenes :datos de base de datos directorio mysql
- medio ambiente :configure la variable de entorno 'MYSQL_ROOT_PASSWORD ' para la contraseña raíz de mysql para las imágenes de la ventana acoplable, ejecutada al construir el contenedor.
- Configuración de los servicios de PHPMyAdmin
El último bloque, pega la configuración a continuación:
phpmyadmin:
image: 'phpmyadmin/phpmyadmin'
restart: always
ports:
- '8080:80'
links:
- mysql:mysql
environment:
MYSQL_USERNAME: root
MYSQL_ROOT_PASSWORD: hakase-labs123
PMA_HOST: mysql
Estamos usando una imagen acoplable 'phpmyadmin', mapeando el puerto del contenedor 80 a 8080 en el host, vincule el contenedor a mariadb contenedor, configure reiniciar siempre y configure algunas variables de entorno de la imagen de la ventana acoplable, incluido el conjunto 'PMA_HOST '.
Guarde el archivo y salga de vim.
Puede ver el ejemplo completo en github.
Paso 5:ejecutar Docker-Compose
Ahora estamos listos para ejecutar docker-compose. Nota:cuando desee ejecutar docker-compose, debe estar en el directorio del proyecto docker-compose y asegurarse de que esté el archivo yml con la configuración de composición.
Ejecute el siguiente comando para activar la pila LEMP:
docker-compose up -d
-d: ejecutándose como demonio o en segundo plano
Verá el resultado de que se han creado los nuevos contenedores, compruébelo con el siguiente comando:
docker-compose ps
Ahora tenemos cuatro contenedores que ejecutan Nginx, PHP-fpm, MariaDB y PHPMyAdmin.
Paso 6 - Prueba
Comprobación de los puertos que utiliza el docker-proxy en el host.
netstat -plntu
Podemos ver el puerto 80 para el contenedor Nginx, el puerto 3306 para el contenedor MariaDB, el puerto 9000 para el contenedor php-fpm y el puerto 8080 para el contenedor PHPMyAdmin.
Acceda al puerto 80 desde el navegador web y verá nuestro archivo index.html.
http://dirección-serverip/
Asegúrese de que PHP-fpm se esté ejecutando, acceda desde el navegador web.
http://dirección-serverip/info.php
Acceda al contenedor de MySQL en el shell de MySQL.
docker-compose exec mysql bash
mysql -u root -p
TYPE MYSQL PASSWORD: hakase-labs123
Ahora cree una nueva base de datos:
create database hakase_db;
exit
Se puede acceder al contenedor de shell MariaDB mysql y hemos creado una nueva base de datos 'hakase_db '.
A continuación, acceda a PHPMyAdmin en el puerto 8080:http://serverip-address:8080/.
Verá la página de inicio de sesión de PHPMyAdmin, simplemente escriba el nombre de usuario 'root ' y la contraseña es 'hakase-labs123 '.
Se conectará automáticamente al contenedor mysql que se ha definido en el PMA_HOST variable de entorno.
Haga clic en 'Ir ' y verá el panel de phpmyadmin que está conectado a 'mysql ' contenedor.
¡Éxito! La pila LEMP se ejecuta bajo una configuración docker-compose, que consta de cuatro contenedores.
Referencia
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/lemp-compose