Docker es la virtualización a nivel de sistema operativo destinada principalmente a desarrolladores y administradores de sistemas. Docker facilita la creación y el despliegue de aplicaciones en un entorno aislado. Un Dockerfile es un script que contiene colecciones de comandos e instrucciones que se ejecutarán automáticamente en secuencia en el entorno de la ventana acoplable para crear una nueva imagen de la ventana acoplable.
En este tutorial, le mostraré cómo crear su propia imagen acoplable con un archivo acoplable. Explicaré la secuencia de comandos de dockerfile en detalle para que pueda crear sus propias secuencias de comandos de dockerfile.
Requisito previo
- Un servidor Linux:usaré Ubuntu 16.04 como máquina host y Ubuntu 16.04 como imagen base de la ventana acoplable.
- Privilegios de raíz.
- Comprender el comando Docker
Introducción al comando Dockerfile
Un dockerfile es un script que contiene una colección de comandos de dockerfile y comandos del sistema operativo (por ejemplo, comandos de Linux). Antes de crear nuestro primer dockerfile, debe familiarizarse con el comando dockerfile.
A continuación se muestran algunos comandos de Dockerfile que debe conocer:
DE
La imagen base para construir una nueva imagen. Este comando debe estar encima del dockerfile.
MANTENEDOR
Opcional, contiene el nombre del mantenedor de la imagen.
CORRE
Se utiliza para ejecutar un comando durante el proceso de creación de la imagen de la ventana acoplable.
AÑADIR
Copie un archivo de la máquina host a la nueva imagen de la ventana acoplable. Hay una opción para usar una URL para el archivo, Docker luego descargará ese archivo al directorio de destino.
ENV
Defina una variable de entorno.
CMD
Se utiliza para ejecutar comandos cuando creamos un nuevo contenedor a partir de la imagen de la ventana acoplable.
PUNTO DE ENTRADA
Defina el comando predeterminado que se ejecutará cuando se ejecute el contenedor.
DIR.TRABAJO
Esta es la directiva para ejecutar el comando CMD.
USUARIO
Configure el usuario o UID para el contenedor creado con la imagen.
VOLUMEN
Habilite el acceso/directorio vinculado entre el contenedor y la máquina host.
Ahora comencemos a crear nuestro primer dockerfile.
Paso 1:Instalación de Docker
Inicie sesión en su servidor y actualice el repositorio de software.
ssh [email protected]
apt-get update
Instale docker.io con este comando apt:
apt-get install docker.io
Cuando finalice la instalación, inicie el servicio Docker y habilítelo para que se inicie en el momento del arranque:
systemctl start docker
systemctl enable docker
Docker se ha instalado y se está ejecutando en el sistema.
Paso 2:Crear Dockerfile
En este paso, crearemos un nuevo directorio para el dockerfile y definiremos qué queremos hacer con ese dockerfile.
Cree un nuevo directorio y un dockerfile nuevo y vacío dentro de ese directorio.
mkdir ~/myimages
cd myimages/
touch Dockerfile
A continuación, defina lo que queremos hacer con nuestra nueva imagen personalizada. En este tutorial, instalaré Nginx y PHP-FPM 7 usando una imagen acoplable de Ubuntu 16.04. Además, necesitamos Supervisord, por lo que podemos iniciar Nginx y PHP-FPM 7 en un solo comando.
Edite el 'Dockerfile' con vim:
nano Dockerfile
En la parte superior del archivo, agregue una línea con la imagen base (Ubuntu 16.04) que queremos usar.
#Download base image ubuntu 16.04
FROM ubuntu:16.04
Actualice el repositorio de software de Ubuntu dentro del dockerfile con el comando 'EJECUTAR'.
# Update Ubuntu Software repository
RUN apt-get update
Luego instale las aplicaciones que necesitamos para la imagen personalizada. Instale Nginx, PHP-FPM y Supervisord desde el repositorio de Ubuntu con apt. Agregue los comandos EJECUTAR para la instalación de Nginx y PHP-FPM.
# Install nginx, php-fpm and supervisord from ubuntu repository
RUN apt-get install -y nginx php7.0-fpm supervisor && \
rm -rf /var/lib/apt/lists/*
En esta etapa, todas las aplicaciones están instaladas y necesitamos configurarlas. Configuraremos Nginx para manejar aplicaciones PHP editando la configuración de host virtual predeterminada. Podemos reemplazarlo por nuestro nuevo archivo de configuración, o podemos editar el archivo de configuración existente con el comando 'sed'.
En este tutorial, reemplazaremos la configuración de host virtual predeterminada con una nueva configuración usando el comando 'COPY' dockerfile.
#Define the ENV variable
ENV nginx_vhost /etc/nginx/sites-available/default
ENV php_conf /etc/php/7.0/fpm/php.ini
ENV nginx_conf /etc/nginx/nginx.conf
ENV supervisor_conf /etc/supervisor/supervisord.conf
# Enable php-fpm on nginx virtualhost configuration
COPY default ${nginx_vhost}
RUN sed -i -e 's/;cgi.fix_pathinfo=1/cgi.fix_pathinfo=0/g' ${php_conf} && \
echo "\ndaemon off;" >> ${nginx_conf}
A continuación, configure Supervisord para Nginx y PHP-FPM. Reemplazaremos la configuración predeterminada de Supervisor con una nueva configuración usando el comando 'COPY'.
#Copy supervisor configuration
COPY supervisord.conf ${supervisor_conf}
Ahora cree un nuevo directorio para el archivo sock php-fpm y cambie el propietario del directorio /var/www/html y el directorio PHP a www-data.
RUN mkdir -p /run/php && \
chown -R www-data:www-data /var/www/html && \
chown -R www-data:www-data /run/php
A continuación, defina el volumen para que podamos montar los directorios que se enumeran a continuación en la máquina host.
# Volume configuration
VOLUME ["/etc/nginx/sites-enabled", "/etc/nginx/certs", "/etc/nginx/conf.d", "/var/log/nginx", "/var/www/html"]
Finalmente, configure el comando de contenedor predeterminado 'CMD' y abra el puerto para HTTP y HTTPS. Crearemos un nuevo archivo start.sh para el comando 'CMD' predeterminado cuando se inicie el contenedor. El archivo contiene el comando 'supervisord' y copiaremos el archivo a la nueva imagen con el comando 'COPY' dockerfile.
# Configure Services and Port
COPY start.sh /start.sh
CMD ["./start.sh"]
EXPOSE 80 443
Guarde el archivo y salga.
Aquí está el Dockerfile completo en una sola pieza:
#Download base image ubuntu 16.04
FROM ubuntu:16.04
# Update Software repository
RUN apt-get update
# Install nginx, php-fpm and supervisord from ubuntu repository
RUN apt-get install -y nginx php7.0-fpm supervisor && \
rm -rf /var/lib/apt/lists/*
#Define the ENV variable
ENV nginx_vhost /etc/nginx/sites-available/default
ENV php_conf /etc/php/7.0/fpm/php.ini
ENV nginx_conf /etc/nginx/nginx.conf
ENV supervisor_conf /etc/supervisor/supervisord.conf
# Enable php-fpm on nginx virtualhost configuration
COPY default ${nginx_vhost}
RUN sed -i -e 's/;cgi.fix_pathinfo=1/cgi.fix_pathinfo=0/g' ${php_conf} && \
echo "\ndaemon off;" >> ${nginx_conf}
#Copy supervisor configuration
COPY supervisord.conf ${supervisor_conf}
RUN mkdir -p /run/php && \
chown -R www-data:www-data /var/www/html && \
chown -R www-data:www-data /run/php
# Volume configuration
VOLUME ["/etc/nginx/sites-enabled", "/etc/nginx/certs", "/etc/nginx/conf.d", "/var/log/nginx", "/var/www/html"]
# Configure Services and Port
COPY start.sh /start.sh
CMD ["./start.sh"]
EXPOSE 80 443
Ahora dentro de nuestro directorio 'Dockerfile', cree un nuevo archivo de configuración para el host virtual llamado 'predeterminado', un archivo de configuración de supervisor 'supervisord.conf' y un script de configuración de servicio 'start.sh'.
vim default
Pegue la configuración de host virtual predeterminada a continuación:
server {
listen 80 default_server;
listen [::]:80 default_server;
root /var/www/html;
index index.html index.htm index.nginx-debian.html;
server_name _;
location / {
try_files $uri $uri/ =404;
}
location ~ \.php$ {
include snippets/fastcgi-php.conf;
fastcgi_pass unix:/run/php/php7.0-fpm.sock;
}
# deny access to .htaccess files, if Apache's document root
# concurs with nginx's one
#
#location ~ /\.ht {
# deny all;
#}
} Archivo de configuración supervisado:
vim supervisord.conf
Pegue la configuración a continuación:
[unix_http_server]
file=/dev/shm/supervisor.sock ; (the path to the socket file)
[supervisord]
logfile=/var/log/supervisord.log ; (main log file;default $CWD/supervisord.log)
logfile_maxbytes=50MB ; (max main logfile bytes b4 rotation;default 50MB)
logfile_backups=10 ; (num of main logfile rotation backups;default 10)
loglevel=info ; (log level;default info; others: debug,warn,trace)
pidfile=/tmp/supervisord.pid ; (supervisord pidfile;default supervisord.pid)
nodaemon=false ; (start in foreground if true;default false)
minfds=1024 ; (min. avail startup file descriptors;default 1024)
minprocs=200 ; (min. avail process descriptors;default 200)
user=root ;
; the below section must remain in the config file for RPC
; (supervisorctl/web interface) to work, additional interfaces may be
; added by defining them in separate rpcinterface: sections
[rpcinterface:supervisor]
supervisor.rpcinterface_factory = supervisor.rpcinterface:make_main_rpcinterface
[supervisorctl]
serverurl=unix:///dev/shm/supervisor.sock ; use a unix:// URL for a unix socket
; The [include] section can just contain the "files" setting. This
; setting can list multiple files (separated by whitespace or
; newlines). It can also contain wildcards. The filenames are
; interpreted as relative to this file. Included files *cannot*
; include files themselves.
[include]
files = /etc/supervisor/conf.d/*.conf
[program:php-fpm7.0]
command=/usr/sbin/php-fpm7.0 -F
numprocs=1
autostart=true
autorestart=true
[program:nginx]
command=/usr/sbin/nginx
numprocs=1
autostart=true
autorestart=true
Archivo de inicio.sh.
vim start.sh
Pegue la configuración a continuación:
#!/bin/sh
/usr/bin/supervisord -n -c /etc/supervisor/supervisord.conf
Guardar y salir
Haga ejecutable start.sh con el comando chmod:
chmod +x start.sh
Guarde el archivo y salga.
Paso 3:crear una nueva imagen de Docker y crear un nuevo contenedor basado en ella
Se han creado el Dockerfile y todos los archivos de configuración requeridos, ahora podemos crear una nueva imagen de docker basada en Ubuntu 16.04 y nuestro dockerfile con el siguiente comando de docker:
docker build -t nginx_image .
Cuando el comando se completó con éxito, podemos verificar la nueva imagen 'nginx_image' con el siguiente comando docker:
docker images
Luego podemos intentar crear un nuevo contenedor basado en nginx_images. Y antes de crear un nuevo contenedor, podemos crear un nuevo directorio en la máquina host para los datos webroot.
mkdir -p /webroot
Ahora ejecute el nuevo contenedor con el siguiente comando:
docker run -d -v /webroot:/var/www/html -p 80:80 --name hakase nginx_image
Luego podemos comprobar que se está ejecutando el nuevo contenedor con el nombre hakase basado en 'nginx_image':
docker ps
- --nombre hakase nginx_image =Creamos un nuevo contenedor con el nombre 'hakase', basado en la imagen acoplable 'nginx_images'.
- -p 80:80 =contenedor hakase ejecutándose en el puerto 80 en la máquina host.
- -v /webroot:/var/www/html =directorio /webroot en la máquina host reescriba el directorio /var/www/html en el contenedor.
El nuevo contenedor basado en nginx_image se está ejecutando sin errores.
Paso 4:probar Nginx y PHP-FPM en el contenedor
Intente crear un nuevo archivo index.html en el directorio /webroot con echo:
echo '<h1>Nginx and PHP-FPM 7 inside Docker Container</h1>' > /webroot/index.html
Prueba con el comando curl accediendo a la dirección IP de la máquina host.
curl 192.168.1.250
curl -I 192.168.1.250
Veremos los resultados a continuación.
A continuación, pruebe que PHP-FPM 7.0 se está ejecutando creando un nuevo archivo phpinfo en el directorio /webroot de la máquina host.
echo '<?php phpinfo(); ?>' > /webroot/info.php
Abra el navegador web y escriba la dirección IP de la máquina host:
http://192.168.1.248/info.php
Ahora puede ver la salida del archivo phpinfo.
la nueva imagen acoplable 'nginx_image' se ha creado con éxito, ahora podemos crear más contenedores basados en esa imagen.