Jak zainstalować Ruby on Rails na serwerze Linux (Ubuntu 24.04, Rocky Linux 9, Debian, AlmaLinux, CentOS)

Ten kompleksowy przewodnik, dostarczony przez niekwestionowanego Króla Serwerów, Łukasza Bodzionego, poprowadzi Cię przez proces instalacji i konfiguracji frameworka Ruby on Rails na różnych dystrybucjach Linux. Wykraczamy poza podstawową instalację, włączając w to nowoczesne praktyki DevOps z wykorzystaniem Dockera do konteneryzacji, Ansible do automatyzacji, Kubernetes do orkiestracji i Terraform do zarządzania infrastrukturą jako kodem. Takie podejście zapewnia niezawodne, skalowalne i łatwe w utrzymaniu środowisko dla Twoich aplikacji internetowych.

Wprowadzenie do Ruby on Rails i nasza filozofia konfiguracji

Ruby on Rails (często skracany do "Rails") to potężny framework do tworzenia aplikacji internetowych, znany z szybkości i prostoty, jakie oferuje deweloperom. Aby zmaksymalizować jego potencjał w środowiskach produkcyjnych, kluczowe jest wykorzystanie nowoczesnych narzędzi, które zapewnią wysoką dostępność, bezpieczeństwo i łatwość zarządzania. W tym przewodniku pokażemy, jak zainstalować Ruby on Rails i zbudować wokół niego solidną infrastrukturę, gotową na wymagania produkcyjne.

Krok 1: Przygotowanie systemu bazowego

Niezależnie od wybranej dystrybucji Linux, zacznij od aktualizacji systemu i instalacji niezbędnych narzędzi.

Dla Ubuntu / Debian:

sudo apt update && sudo apt upgrade -y
sudo apt install -y curl wget git vim ca-certificates gnupg

Następnie zainstaluj zależności potrzebne do zbudowania Ruby:

sudo apt install -y build-essential libssl-dev libreadline-dev zlib1g-dev libncurses5-dev libffi-dev libgdbm-dev

Dla Rocky Linux 9 / AlmaLinux / CentOS:

sudo dnf -y update
sudo dnf install -y curl wget git vim ca-certificates dnf-plugins-core

Następnie zainstaluj zależności potrzebne do zbudowania Ruby:

sudo dnf group install -y "Development Tools"
sudo dnf install -y openssl-devel libyaml-devel libffi-devel readline-devel zlib-devel gdbm-devel ncurses-devel

Krok 2: Instalacja Ruby i Rails

Zamiast używać systemowego pakietu Ruby, zaleca się użycie menedżera wersji, takiego jak RVM lub rbenv. Poniżej przedstawiono przykład instalacji z użyciem rbenv.

# Instalacja rbenv i ruby-build (plugin do instalacji wersji Ruby)
git clone https://github.com/rbenv/rbenv.git ~/.rbenv
git clone https://github.com/rbenv/ruby-build.git ~/.rbenv/plugins/ruby-build

# Dodanie rbenv do PATH
echo 'export PATH="$HOME/.rbenv/bin:$PATH"' >> ~/.bashrc
echo 'eval "$(rbenv init -)"' >> ~/.bashrc
source ~/.bashrc

# Instalacja najnowszej wersji Ruby
rbenv install 3.3.0 # Zmień na najnowszą stabilną wersję
rbenv global 3.3.0

# Sprawdzenie wersji Ruby
ruby -v

# Instalacja Rails
gem install rails
rbenv rehash

# Sprawdzenie wersji Rails
rails -v

Krok 3: Instalacja Dockera (dla wszystkich dystrybucji)

Docker jest doskonałym narzędziem do konteneryzacji aplikacji Ruby on Rails. Użyjemy go do stworzenia spójnego i izolowanego środowiska.

Dla Ubuntu / Debian:

sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
echo \
  "deb [arch="$(dpkg --print-architecture)" signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
  "$(. /etc/os-release && echo "$VERSION_CODENAME")" stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt update
sudo apt install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

Dla Rocky Linux 9 / AlmaLinux / CentOS:

sudo dnf config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
sudo dnf install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
sudo systemctl enable docker --now

Dodaj swojego użytkownika do grupy docker (dla wszystkich dystrybucji):

sudo usermod -aG docker $USER
newgrp docker

Krok 4: Konfiguracja Docker Compose dla Ruby on Rails

Stworzymy plik docker-compose.yml, który zdefiniuje całą naszą aplikację Rails, włączając w to serwer baz danych (PostgreSQL), serwer aplikacji (Puma) i serwer proxy (Nginx).

version: '3.8'

services:
  db:
    image: postgres:15-alpine
    restart: always
    environment:
      POSTGRES_DB: app_production
      POSTGRES_USER: rails_user
      POSTGRES_PASSWORD: your_db_password # **ZMIEN TO**
    volumes:
      - pg_data:/var/lib/postgresql/data

  web:
    build: . # Użyj lokalnego Dockerfile
    command: bundle exec rails server -b 0.0.0.0
    ports:
      - "3000:3000"
    volumes:
      - .:/app
    depends_on:
      - db
    environment:
      RAILS_ENV: production
      DATABASE_URL: postgres://rails_user:your_db_password@db/app_production

  nginx:
    image: nginx:stable-alpine
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx/nginx.conf:/etc/nginx/nginx.conf:ro
      - ./nginx/conf.d:/etc/nginx/conf.d:ro
      - ./public:/var/www/html:ro # Dla plików statycznych
    depends_on:
      - web
    restart: always

volumes:
  pg_data:

Utwórz Dockerfile (w katalogu głównym projektu Rails):

FROM ruby:3.3.0-alpine

RUN apk add --no-cache \
    build-base \
    postgresql-dev \
    nodejs \
    yarn \
    tzdata \
    shared-mime-info \
    file

WORKDIR /app

COPY Gemfile Gemfile.lock ./
RUN gem install bundler && bundle install --jobs 4

COPY . .

# Tworzenie publicznego katalogu dla Nginxa
RUN rm -rf public && mkdir public

EXPOSE 3000

CMD ["bundle", "exec", "rails", "server", "-b", "0.0.0.0"]

Utwórz konfigurację Nginxa (w ~/magento/nginx/conf.d/):

./nginx/conf.d/rails.conf (zmień yourdomain.com na swoją domenę):

upstream rails {
  server web:3000;
}

server {
    listen 80;
    server_name yourdomain.com www.yourdomain.com;
    return 301 https://$host$request_uri;
}

server {
    listen 443 ssl http2;
    server_name yourdomain.com www.yourdomain.com;

    ssl_certificate /etc/letsencrypt/live/yourdomain.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/yourdomain.com/privkey.pem;

    root /var/www/html;

    location / {
        proxy_pass http://rails;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

Uruchom kontenery:

docker compose up -d --build

Twoja aplikacja Rails będzie działać i będzie dostępna pod Twoją domeną po skonfigurowaniu rekordów DNS i certyfikatów SSL.

Krok 5: Automatyzacja z Ansible

Ansible może zautomatyzować cały proces wdrażania Ruby on Rails, od instalacji Dockera po uruchomienie aplikacji za pomocą Docker Compose. Zapewnia to spójność i powtarzalność w procesie wdrażania na wielu serwerach.

# inventory.ini
[rails_servers]
your_server_ip ansible_user=your_ssh_user

# playbook.yml
---
- name: Deploy Ruby on Rails with Docker
  hosts: rails_servers
  become: yes
  vars:
    app_root: /opt/rails_app
    db_password: "YourStrongDBPassword"
    domain_name: yourdomain.com

  tasks:
    - name: Update system cache (dla Debian/Ubuntu)
      apt: update_cache=yes
      when: ansible_os_family == 'Debian'

    - name: Update system cache (dla Rocky Linux/AlmaLinux/CentOS)
      dnf: update_cache=yes
      when: ansible_os_family == 'RedHat'

    - name: Instalacja Dockera
      # ... (pomińmy szczegóły, aby uniknąć redundancji, jak w poprzednich artykułach) ...
      # Tutaj możesz umieścić kod instalujący Dockera i docker-compose

    - name: Utworzenie katalogów projektu
      file:
        path: "{{ app_root }}/{{ item }}"
        state: directory
        mode: '0755'
      loop:
        - "public"
        - "nginx/conf.d"

    - name: Kopiowanie pliku docker-compose.yml
      template:
        src: ./docker-compose.yml.j2
        dest: "{{ app_root }}/docker-compose.yml"
      # ... (i innych plików konfiguracyjnych)

    - name: Uruchomienie aplikacji za pomocą Docker Compose
      community.docker.docker_compose:
        project_src: "{{ app_root }}"
        state: present

Krok 6: Orkiestracja z Kubernetes (dla zaawansowanych)

W przypadku wdrożeń na dużą skalę, Kubernetes jest idealnym rozwiązaniem. Umożliwia on orkiestrację kontenerów, automatyczne skalowanie i zapewnienie wysokiej dostępności. Twoja aplikacja Rails, baza danych i serwer proxy zostaną zdefiniowane jako oddzielne zasoby Kubernetes (Deployments, Services, Persistent Volumes, Ingress).

Oto uproszczona koncepcja wdrożenia Rails na Kubernetes:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: rails-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: rails-app
  template:
    metadata:
      labels:
        app: rails-app
    spec:
      containers:
      - name: rails
        image: your-repo/rails-app:latest
        env:
        - name: DATABASE_URL
          value: "postgres://rails_user:your_db_password@rails-db-service/app_production"
        ports:
        - containerPort: 3000
---
apiVersion: v1
kind: Service
metadata:
  name: rails-app-service
spec:
  selector:
    app: rails-app
  ports:
    - port: 80
      targetPort: 3000
  type: ClusterIP

Wdrożenie obejmowałoby również konfigurację dla bazy danych PostgreSQL (Deployment, Service, PVC) oraz kontroler Ingress, który kierowałby ruch z zewnątrz do serwisu `rails-app-service`, zapewniając obsługę SSL i domen.

Krok 7: Infrastruktura jako kod z Terraform

Terraform umożliwia zarządzanie całą infrastrukturą (serwerami, sieciami, klastrami Kubernetes) za pomocą kodu. Dzięki temu Twoje środowisko jest powtarzalne i łatwe do skalowania.

Przykładowa koncepcja Terraform dla serwera Ubuntu 24.04:

resource "aws_instance" "rails_server" {
  ami           = "ami-0abcdef1234567890" # Zmień na odpowiednie AMI dla Ubuntu/Rocky/Debian
  instance_type = "t3.medium"
  key_name      = "my-ssh-key"
  tags = {
    Name = "Rails-Ubuntu2404"
  }
}

Po zainicjowaniu serwera za pomocą Terraform, można by użyć Ansible do wdrożenia aplikacji Rails z Dockerem. Alternatywnie, Terraform może stworzyć cały klaster Kubernetes, a następnie manifesty Kubernetes zajmą się wdrożeniem aplikacji Rails.