1. Anchor for re-using code in yaml file.

   x-app: &app

   This shared code will used below at app and sidekiq services. Here we set development image name, build context, target stage at Dockerfile and set development environment variables. Also set local .env file as storage for your own development secrets.

   • build:
     Section used by docker compose build app command to build our image and tag is by name that read from image key initapp-rails in out case. Last app is argument witch is name of our service. So it will same as command: docker build -t initapp-rails --target development . Where . is context (current directory), target is development stage at Dockerfile and initapp-rails is name of our generated image.
     Docker commannd use Dockerfile from working directory by default. Specify another file by simply adding dockerfile to build section services: app: build: dockerfile: Dockerfile.other
     And now docker compose build app will be equal to the: docker build -t initapp-rails --target development -f Dockerfile.other .

   • env_file:
     List of file with environment varibles that will be passed to the container at runtime. Gitignored .env file where your can store own secrets required for development or debugging third-party integrations. Ensure that file exists before application starts by touch .env

   • stdin_open: true
     For debugging application usign debugger gem, read how at readme section.

   • ports:
     Here is a list of ports that will be exposed from container to your host machine in format:- host_port:container_port. We use ${PORT:-3000} for host and container - read it as using PORT environment varible if it is set or 3000 by default.
     We solve two things with this code:
     You able to run few projects at the same time by setting own PORT=4000 environment varible at .env file.
     Also PORT is used by default by puma or foreman as a port where application running and you will see nice output with a container port at console that will match with host.

     app-1  | Puma starting in single mode...
     app-1  | * Puma version: 6.4.2 (ruby 3.2.5-p208) ("The Eagle of Durango")
     app-1  | *  Min threads: 5
     app-1  | *  Max threads: 5
     app-1  | *  Environment: development
     app-1  | *          PID: 1
     app-1  | * Listening on http://0.0.0.0:4000
     app-1  | Use Ctrl-C to stop

     No need to remember or open compose.yml file to remeber on which port application is running.

   • tmpfs
     This list of folders will be mounted as temporary volume. It is used to store temporary files that are not persisted between container restarts. Every restart of puma there will be generated new pidfile.

   • depends_on
     Here we define that our app container depends on postgres and redis container. It means that app container will be started after postgres and redis containers. condition: service_healthy Ensure that postgres and redis containers are healthy before starting app container. You can define how to check that container is healthy by configuring healthcheck: section.

   • healthcheck
     Here we define how docker will ensure that containers are healthy. Healthy mean that command at healthcheck: test: ["CMD", "redis-cli", "ping"] block will exited and exited with 0 (success) status code. And self-explaningable fields to set healtcheck interval, timeout and retries.

   • volumes
     Here we define list of volumes that will be mounted to the container. It can be some relative path from you project root directory like:

     At volume section - ./:/app:c mounts current directory to the container at /app folder.
     - cache:/app/tmp/cache:d mounts cache volume to the container at /app/tmp/cache folder.
     - bundle:/usr/local/bundle:d mounts bundle volume to the container at /usr/local/bundle folder.
     - node_modules:/app/node_modules:d mounts node_modules volume to the container at /app/node_modules folder.
     Fifth line: - data:/data:d mounts data volume to the container at /data folder. This needed for sharing gems, nodejs modules and data between containers and containers restarts.

     You need to define named volume at volumes: section.

2. app

   Service that runs Ruby on Rails application container using Procfile.dev.

   At command section we define the command that will be executed inside the app container when docker compose starts: bin/dev --auto-deps-install --auto-migrate

   This script performs the following tasks:

   • Ensures Ruby gems and Node packages are installed
   • Creates database on first run
   • Applies Rails migrations
   • Runs processes defined in Procfile.dev including:
     • Puma web server
     • CSS compilation
     • JavaScript compilation
   content

3. sidekiq

   service that run sidekiq jobs processing.

4. Redis

   Run Redis container. That we use for sidekiq jobs processing and cache.

5. Postgres

   Run a PostgreSQL database container. It uses a specific image version and maintains persistent data through a postgres named volume.

6. Mailcatcher

   Run a Mailcatcher container. It is optional and used at initapp-rails project for local email sending testing.

Volumes

Volumes are used to persist data between containers restarts. Once you define it docker will create it following ${name_section_or_root_folder_name}_${volume_name} convention. For example in our project for data volume complete name will be initapp-rails_data. Run docker volume inspect initapp-rails_data to see volume details and exact location at your machine.