# Utiliza contenedores para el desarrollo con Ruby on Rails


## Prerrequisitos

Completa [Contenerizar una aplicación de Ruby on Rails](/guides/ruby/develop/containerize/).

---

## Resumen

En esta sección, aprenderás cómo configurar un entorno de desarrollo para tu aplicación contenerizada. Esto incluye:

- Agregar una base de datos local y persistir datos
- Configurar Compose para actualizar automáticamente los servicios de Compose en ejecución mientras editas y guardas tu código

---

## Agrega una base de datos local y persiste los datos

Puedes utilizar contenedores para configurar servicios locales, como una base de datos. En esta sección, actualizarás el archivo `compose.yaml` para definir un servicio de base de datos y un volumen para persistir los datos.

En el directorio del repositorio clonado, abre el archivo `compose.yaml` en un IDE o editor de texto. Debes agregar el archivo de contraseña de la base de datos como una variable de entorno al servicio del servidor y especificar el archivo de secreto a utilizar.

El siguiente es el archivo `compose.yaml` actualizado.

```yaml {hl_lines="07-25"}
services:
  web:
    build: .
    command: bundle exec rails s -b '0.0.0.0'
    ports:
      - "3000:3000"
    depends_on:
      - db
    environment:
      - RAILS_ENV=test
    env_file: "webapp.env"
  db:
    image: postgres:18
    secrets:
      - db-password
    environment:
      - POSTGRES_PASSWORD_FILE=/run/secrets/db-password
    volumes:
      - postgres_data:/var/lib/postgresql

volumes:
  postgres_data:
secrets:
  db-password:
    file: db/password.txt
```

> [!NOTE]
>
> Para obtener más información sobre las instrucciones en el archivo Compose, consulta la [referencia del archivo Compose](/reference/compose-file/).

Antes de ejecutar la aplicación utilizando Compose, observa que este archivo Compose especifica un archivo `password.txt` para contener la contraseña de la base de datos. Debes crear este archivo, ya que no está incluido en el repositorio fuente.

En el directorio del repositorio clonado, crea un nuevo directorio llamado `db` y, dentro de ese directorio, crea un archivo llamado `password.txt` que contenga la contraseña para la base de datos. Utilizando tu IDE o editor de texto favorito, agrega el siguiente contenido al archivo `password.txt`.

```text
mysecretpassword
```

Guarda y cierra el archivo `password.txt`. Además, en el archivo `webapp.env` puedes cambiar la contraseña para conectarte a la base de datos.

Ahora deberías tener el siguiente contenido en tu directorio `docker-ruby-on-rails`.

```text
.
├── Dockerfile
├── Gemfile
├── Gemfile.lock
├── README.md
├── Rakefile
├── app/
├── bin/
├── compose.yaml
├── config/
├── config.ru
├── db/
│   ├── development.sqlite3
│   ├── migrate
│   ├── password.txt
│   ├── schema.rb
│   └── seeds.rb
├── lib/
├── log/
├── public/
├── storage/
├── test/
├── tmp/
└── vendor
```

Ahora, ejecuta el siguiente comando `docker compose up` para iniciar tu aplicación.

```console
$ docker compose up --build
```

En Ruby on Rails, `db:migrate` es una tarea de Rake que se utiliza para ejecutar migraciones en la base de datos. Las migraciones son una forma de alterar la estructura del esquema de tu base de datos a lo largo del tiempo de manera consistente y sencilla.

```console
$ docker exec -it docker-ruby-on-rails-web-1 rake db:migrate RAILS_ENV=test
```

Verás un mensaje similar a este:

```console
== 20240710193146 CreateWhales: migrating =====================================
-- create_table(:whales)
   -> 0.0126s
== 20240710193146 CreateWhales: migrated (0.0127s) ============================
```

Actualiza <http://localhost:3000> en tu navegador y agrega las ballenas (whales).

Presiona `ctrl+c` en la terminal para detener tu aplicación y vuelve a ejecutar `docker compose up`; las ballenas se mantendrán persistidas.

---

## Actualiza automáticamente los servicios

Utiliza Compose Watch para actualizar automáticamente los servicios de Compose que se encuentran en ejecución a medida que editas y guardas tu código. Para obtener más detalles sobre Compose Watch, consulta [Usar Compose Watch](/compose/how-tos/file-watch/).

Abre tu archivo `compose.yaml` en un IDE o editor de texto y luego agrega las instrucciones de Compose Watch. El siguiente es el archivo `compose.yaml` actualizado.

```yaml {hl_lines="13-16"}
services:
  web:
    build: .
    command: bundle exec rails s -b '0.0.0.0'
    ports:
      - "3000:3000"
    depends_on:
      - db
    environment:
      - RAILS_ENV=test
    env_file: "webapp.env"

    develop:
      watch:
        - action: rebuild
          path: .
  db:
    image: postgres:18
    secrets:
      - db-password
    environment:
      - POSTGRES_PASSWORD_FILE=/run/secrets/db-password
    volumes:
      - postgres_data:/var/lib/postgresql

volumes:
  postgres_data:
secrets:
  db-password:
    file: db/password.txt
```

Ejecuta el siguiente comando para iniciar tu aplicación con Compose Watch.

```console
$ docker compose watch
```

Cualquier cambio en los archivos fuente de la aplicación en tu máquina local se reflejará inmediatamente en el contenedor en ejecución.

Abre `docker-ruby-on-rails/app/views/whales/index.html.erb` en un IDE o editor de texto y actualiza la cadena `Whales` agregando un signo de exclamación.

```diff
-    <h1>Whales</h1>
+    <h1>Whales!</h1>
```

Guarda los cambios en `index.html.erb` y luego espera unos segundos a que la aplicación se vuelva a compilar. Ve a la aplicación nuevamente y verifica que aparezca el texto actualizado.

Presiona `ctrl+c` en la terminal para detener tu aplicación.

---

## Resumen

En esta sección, revisaste la configuración de tu archivo Compose para agregar una base de datos local y persistir datos. También aprendiste a utilizar Compose Watch para reconstruir y ejecutar automáticamente tu contenedor cuando actualizas tu código.

Información relacionada:

- [Referencia del archivo Compose](/reference/compose-file/)
- [Compose file watch](/compose/how-tos/file-watch/)
- [Compilaciones de múltiples etapas](/build/building/multi-stage/)

## Próximos pasos

En la siguiente sección, aprenderás cómo puedes probar y depurar localmente tus cargas de trabajo en Kubernetes antes de realizar el despliegue.