¡Esta es una revisión vieja del documento!
En el tema anterior vimos lo básico para empezar a usar Docker. En este tema vamos a ver aspectos mas avanzados de Docker y trucos a tener en cuenta para usarlo.
Mas información:
Podemos crear nuestras propias imágenes si ninguna de las que hay hace lo que nosotros necesitamos. PAra ello usaremos el comando docker build
.
El comando docker build
se utiliza para construir imágenes de contenedor Docker a partir de un Dockerfile. A continuación se presentan las principales características y uso de este comando.
<shx>
docker build -t nombre_imagen:etiqueta ruta_del_dockerfile
</shx>
Donde:
Dockerfile
por lo que sea pondrá un punto indicando que es el directorio actual.mi_aplicacion_web:1.0
sabiendo que el fichero Dockerfile
está en la carpeta actual.<shx> docker build -t mi_aplicacion_web:1.0 . </shx>
Un Dockerfile contiene instrucciones para la construcción de una imagen. Aquí se muestra una estructura básica:
# Especifica la imagen base FROM imagen_base:version # Instrucciones para configurar la imagen RUN comando1 RUN comando2 # Copia archivos locales al contenedor COPY origen destino # Expone un puerto en el contenedor EXPOSE puerto # Define variables de entorno ENV variable=valor # Comando para ejecutar la aplicación o servicio CMD ["comando", "argumento"]
- FROM: Indica la imagen base desde la cual se construirá la nueva imagen. La versión es opcional.
# Comentario: Descripción del propósito de la imagen FROM imagen_base:version # Especifica la imagen base
- RUN: Ejecuta comandos en una nueva capa del contenedor. Se utiliza para instalar paquetes, configurar el entorno y realizar otras acciones durante la construcción de la imagen.
RUN comando1 RUN comando2
- COPY: Copia archivos desde la ruta de origen en la máquina host hacia el contenedor en la ruta de destino.
COPY origen destino
- EXPOSE: Informa a Docker que el contenedor escuchará en el puerto especificado en tiempo de ejecución. No publica el puerto en el host.
EXPOSE puerto
- ENV: Define variables de entorno dentro del contenedor.
ENV variable=valor
- CMD: Especifica el comando predeterminado que se ejecutará cuando el contenedor se inicie.
CMD ["comando", "argumento"]
RUN
y CMD
es que RUN
se ejecuta cuando se crea la imagen con el comando docker build
,es decir configurándola mientras que CMD
se ejecuta cuando se crea el contenedor con el comando docker container run
Docker permite crear redes aisladas entre los distintos contenedores. De esa forma , si un contenedor es atacado, no se tendrá acceso por red al resto de los contenedores sino únicamente a los de su propia red.
Orden | Explicación |
---|---|
docker network create | Crea una red |
docker network rm | Borrar una red |
docker network ls | Ver las redes que hay |
docker network connect | Conecta un contenedor a una red |
docker network disconnect | Desconecta un contenedor de una red |
Para trabajar con redes, lo que debemos hacer es
docker network create nombreDeLaRed
docker network connect nombreDeLaRed nombreDelContenedor
docker container run
con la opción --network=nombreDeLaRed
docker container run \ -dit \ -v /opt/mariadb:/var/lib/mysql \ -e MYSQL_ROOT_PASSWORD=root \ -p 4000:3306 \ --network=nombreDeLaRed \ --name prueba_mariadb \ mariadb:10.1
Docker Compose es una herramienta que permite definir y administrar aplicaciones Docker de múltiples contenedores. Utiliza un archivo YAML para configurar los servicios, las redes y los volúmenes, facilitando la definición y el despliegue de aplicaciones complejas.
Un archivo `docker-compose.yml` define la configuración de una aplicación multi-contenedor. Aquí se presentan las secciones principales:
version: '3' services: servicio1: image: imagen_servicio1 restart: opciones si se reinicia el servidor hostname: nombre del host volumes: - /ruta/host:/ruta/contenedor ports: - "puerto_host:puerto_contenedor" environment: - VARIABLE=valor servicio2: # Configuración del segundo servicio
docker-compose up
docker-compose down
- Muestra el estado de los contenedores definidos en el archivo `docker-compose.yml`.
docker-compose ps
Supongamos un archivo `docker-compose.yml` para una aplicación web con un servicio de frontend y otro de base de datos:
version: '3' services: peliculas_java: image: temurin_peliculas restart: always hostname: peliculas_java volumes: - /opt/peliculas/target:/opt/app ports: - "80:8080" peliculas_mysql: image: mysql:8.3.0 restart: always hostname: peliculas_java environment: - MYSQL_ROOT_PASSWORD=peliculas - MYSQL_DATABASE=peliculas - MYSQL_USER=peliculas - MYSQL_PASSWORD=peliculas
Para iniciar esta aplicación, ejecutamos:
docker-compose up
Esto levantará los contenedores de frontend y base de datos con la configuración especificada.
Docker Compose simplifica la gestión de aplicaciones Docker complejas, permitiendo definir y coordinar múltiples servicios con facilidad.
Crea un contenedor llamado "maria_a" que sean de MariaDB:
Crea un contenedor llamado "maria_b" que sean de MariaDB:
Crea un contenedores llamado "apache_a" que sean del servidor web Apache con PHP:
.env
para guardar los datos de conexión a la base de datos
Crea un contenedores llamado "apache_b" que sean del servidor web Apache con PHP:
.env
para guardar los datos de conexión a la base de datos
Modifica únicamente el fichero .env
de cada servidor para que ahora se conecten a la otra base de datos. Deberá funcionar todo sin problemas.
Vuelve a dejar las conexiones como estaban antes del ejercicio.
Crea ahora dos redes llamadas:
Vuelve a crear los 4 contenedores de antes pero de forma que cada uno esté asociado a una red distinta.
Contenedor | Red |
---|---|
apache_a | red_a |
maria_a | red_a |
apache_b | red_b |
maria_b | red_b |
Prueba que los 2 servidores web siguen funcionando y accediendo a sus bases de datos correspondientes.
Modifica únicamente el fichero .env
de cada servidor para que ahora se conecten a la otra base de datos. No deberán poder conectarse
Vuelve a dejar las conexiones como estaban antes del ejercicio, es decir todas conectadas a "prueba_red".
Hasta ahora para acceder a cada servidor web usabas los puertos 3010
y 3020
. Vamos ahora a usar el servidor Proxy Nginx para que a ambos se pueda acceder por nombre de dominio y todos por el puerto 80. Para ello ya no vamos a usar nuestra máquina sino que vamos a usar la máquina que nos proporciona el centro, a la que nos tenemos que conectar por VPN. En esa máquina ya hemos instalado Nginx como proxy.
En esa máquina haz lo siguiente
VIRTUAL_HOST
vale "tuNombre.daw2.pve2.fpmislata.com"VIRTUAL_PORT
vale "80" /opt/tuNombre/docker/apache
/opt/tuNombre/docker/apache
/opt/tuNombre/docker/mariadb
Prueba a navegar la siguientes url (y deberá funcionar):
Crea un proyecto Web en GitHub llamado "ejemplodaw" en los que haya lo siguiente:
El proyecto es similar al anterior solo que ahora también hay código SASS.
Incluye en el proyecto un script de bash llamado deploy.sh
para desplegar el proyecto en docker. El script se ejecutará con npm run deploy
. El script hará lo siguiente:
src
a dist
dist
el código SASSdist
a /opt/tuNombre/docker/apache
En la máquina real ves a la carpeta /opt/tuNombre
y haz un git clone del proyecto que acabas de crear en GitHub. Se creará la carpeta /opt/tuNombre/ejemplodaw
.
Para probar que todo funciona haz cambios en el SASS en master , súbelos a GitHub y ejecuta dentro de la máquina Linux lo siguiente:
cd /opt/tuNombre/ejemplodaw git fetch --prune --force git checkout master git merge --ff-only origin/master npm run deploy
Prueba a navegar a http://tuNombre.daw2.pve2.fpmislata.com y se verán los cambios.