Docker En Rails - Parte 2
Published: 2022-09-23 20:43:51

Hasta ahora hemos visto cómo crear nuestra aplicación utilizando Docker sin embargo ¿como es que podemos ejecutar nuestra aplicación con Docker?. 

Para poder responder nuestra pregunta anterior lo que necesitaremos es lo siguiente.

- Un archivo para la creación de imágenes (**Dockerfile**).
- Construir nuestra imagen.
- Ejecutar nuestro servidor de Rails con esta imagen creada.

## **El Dockerfile**
Este es un documento que contiene todas las instrucciones que un usuario puede llamar en la línea de comando para la construcción de imágenes. Una vez especifiquemos todos los comandos necesarios para que corra nuestra aplicación podremos utilizar **docker build** el cual podremos ver más adelante para crear nuestra imagen.

Enseguida procederemos a ubicarnos en la raíz de nuestra aplicación y crear el archivo **Dockerfile** con el siguiente contenido.

```Docker
FROM ruby:3.0.4-bullseye

RUN apt-get update -yqq
RUN apt-get install -yqq --no-install-recommends nodejs

COPY . /usr/src/app

WORKDIR /usr/src/app
RUN bundle install
```

Cualquier imagen debe de empezar de algún otro lugar es decir de una imagen preexistente, por lo que esta es la razón por la cual Docker empieza con la instrucción **FROM** la cual especifica la imagen utilizada como punto de inicio.

Pero ¿qué es eso de **3.0.4-bullseye**?, pues bien esta es una imagen de **Ruby** la cual puede ser encontrada en el [hub de docker](https://hub.docker.com/_/ruby) por lo que posteriormente si necesitamos agregar dependencias como **Redis, Postgresql, MySql**, etcétera, este será el lugar adecuado para ir a buscarlas.

Yo en este caso estoy utilizando la versión 3.0.4-bullseye sin embargo tu puedes utilizar la versión que llegues a necesitar.

Enseguida contamos con dos instrucciones **RUN** que son comandos para instalar software en distribuciones de Linux (si no mal recuerdo lo utiliza Ubuntu - Debian), para distribuciones como Fedora se utiliza YUM, pero este es otro tema.

La siguiente línea con la que contamos **COPY** estara como lo dice el comando copiando todos los archivos de nuestro directorio actual a el sistema de archivos de nuestra imagen dentro de **/usr/src/app**.

Enseguida contamos con **WORKDIR** que realiza lo mismo que el comando **cd** de Unix por lo que cambiará a lo que la imagen considera su directorio actual.

Finalmente tenemos la linea **Run bundle install** la cual como sabemos instalará todas las gemas definidas en el Gemfile de nuestro proyecto de Rails.

Con todo esto puesto dentro de nuestro **Dockerfile** procederemos a crear nuestra imagen con el siguiente comando.

```Docker
docker build .
```
Esto como lo comentamos nos creara nuestra imagen por lo que en la salida de terminal tendremos algo parecido a lo siguiente.
![Imagen 1](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/ot1ievpj49ss24oro1y3.png)

Cabe mencionar que el comando docker build  no nos entregara algún archivo en la salida. Este solo va a hacer que la nueva imagen esté disponible, agregandola a la lista de imágenes que Docker conoce y esto lo podemos ver con el comando **docker images**.
![Imagen 2](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/d0rawbmnno3eeynho6vv.png)


## **Ejecutando nuestro servidor de Rails con nuestra imagen**
Ahora que ya tenemos nuestra imagen creada deberíamos de tener la habilidad de levantar nuestro servidor de Rails para ejecutar nuestra aplicación.

Para efectos prácticos vamos a referirnos a nuestra imagen por su ID sin embargo esto cambiará más adelante ya que como podemos apreciar en la última imagen (IMAGE ID) es un alfanumérico que se volvera un martirio estar tipeando en la terminal cada vez.
Por lo tanto para poder levantar Rails dentro del contenedor solo deberemos de ejecutar el siguiente comando.
```Docker
docker run -p 3000:3000 458acbbc731a bin/rails s -b 0.0.0.0
```
Si todo sale de manera correcta lo que tendremos cómo resultado será lo siguiente:
![Imagen 3](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/hm63dbwwrprkpyy86l5g.png)
Enseguida si visitamos la dirección http://localhost:3000 en nuestro navegador podremos apreciar que Rails se está ejecutando de manera correcta.
![Imagen 4](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/m228evwmzg9ut71eoavo.png)
YEI! nuestra aplicación ya se está ejecutando de manera local pero ¿cómo es posible que pueda verlo en mi navegador?.

Pues bien esto se debe a que nosotros por medio de la opción **docker run -p** le indicamos a Docker que haga accesible externamente uno o más puertos.

Por lo que cuando especificamos **-p 3000:3000** estamos indicando al contenedor que publique el puerto 3000 en el puerto 3000 de nuestra máquina local, lo cual viene a significar que una petición a nuestro [localhost](http://localhost):3000 alcanzará a nuestro servidor de Rails dentro del contenedor en el puerto 3000.