Krok 1: Aktualizacja systemu

Zaktualizuj system, aby zapewnić najnowsze pakiety:

sudo dnf update -y
sudo dnf install -y curl git vim

Krok 2: Instalacja PostgreSQL

Zainstaluj PostgreSQL 12 i skonfiguruj bazę danych:

sudo dnf module enable postgresql:12
sudo dnf install -y postgresql-server postgresql-contrib libpq-devel
sudo postgresql-setup --initdb
sudo systemctl start postgresql
sudo systemctl enable postgresql

Utwórz użytkownika i bazę danych dla Rails:

sudo -u postgres psql
CREATE ROLE rails_dev WITH CREATEDB LOGIN PASSWORD 'abc123';
\q

Skonfiguruj uwierzytelnianie w pliku /var/lib/pgsql/data/pg_hba.conf:

sudo vim /var/lib/pgsql/data/pg_hba.conf
# Zmień linię:
# local   all   all   peer
# na:
local   all   all   md5

Zrestartuj PostgreSQL:

sudo systemctl restart postgresql

Krok 3: Instalacja Ruby za pomocą RVM

Zainstaluj Ruby Version Manager (RVM) i Ruby:

curl -sSL https://rvm.io/mpapis.asc | gpg2 --import -
curl -sSL https://rvm.io/pkuczynski.asc | gpg2 --import -
curl -sSL https://get.rvm.io | bash -s stable
source /etc/profile.d/rvm.sh
rvm install ruby-3.1.1
rvm use 3.1.1 --default

Zweryfikuj wersję Ruby:

ruby --version

Spodziewany wynik: ruby 3.1.1p...

Krok 4: Instalacja Node.js i Yarn

Rails wymaga Node.js i Yarn do obsługi zasobów JavaScript:

sudo dnf module enable nodejs:14
sudo dnf install -y nodejs npm
npm install -g yarn

Krok 5: Instalacja Ruby on Rails

Zainstaluj Rails za pomocą gem:

echo "export PATH=$PATH:/usr/local/bin" >> ~/.bashrc
source ~/.bashrc
gem install rails -v 7.0.4
rails --version

Spodziewany wynik: Rails 7.0.4

Krok 6: Tworzenie aplikacji Rails

Utwórz nową aplikację Rails z PostgreSQL:

mkdir -p /var/www
cd /var/www
rails new myapp -d postgresql
cd myapp

Edytuj plik konfiguracyjny bazy danych config/database.yml:

vim config/database.yml

Zaktualizuj sekcje development, test i production:

development:
  <<: *default
  database: myapp_development
  username: rails_dev
  password: abc123
  host: localhost
  port: 5432
test:
  <<: *default
  database: myapp_test
  username: rails_dev
  password: abc123
  host: localhost
  port: 5432
production:
  <<: *default
  database: myapp_production
  username: rails_dev
  password: abc123
  host: localhost
  port: 5432

Utwórz i migruj bazę danych:

rails db:setup
rails db:migrate

Krok 7: Uruchomienie serwera Rails

Uruchom serwer Rails i przetestuj aplikację:

rails server -b 0.0.0.0 -p 3000

Otwórz przeglądarkę i odwiedź http://twoj_ip_serwera:3000. Powinieneś zobaczyć stronę powitalną Rails.

Krok 1: Instalacja Docker i Docker Compose

Zainstaluj Docker i Docker Compose:

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
sudo systemctl start docker
sudo systemctl enable docker
sudo curl -L "https://github.com/docker/compose/releases/download/v2.17.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
sudo chmod +x /usr/local/bin/docker-compose

Krok 2: Tworzenie aplikacji Rails w Docker

Utwórz katalog projektu:

mkdir -p /var/www/myapp
cd /var/www/myapp

Utwórz plik Dockerfile:

FROM ruby:3.1.1

RUN apt-get update -qq && apt-get install -y nodejs postgresql-client
RUN npm install -g yarn

WORKDIR /app
COPY Gemfile Gemfile.lock ./
RUN bundle install

COPY . .

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

Utwórz plik docker-compose.yml:

version: '3.8'
services:
  db:
    image: postgres:14
    volumes:
      - postgres_data:/var/lib/postgresql/data
    environment:
      POSTGRES_USER: rails_dev
      POSTGRES_PASSWORD: abc123
      POSTGRES_DB: myapp_development
  web:
    build: .
    command: bash -c "rm -f tmp/pids/server.pid && rails server -b 0.0.0.0"
    volumes:
      - .:/app
    ports:
      - "3000:3000"
    depends_on:
      - db
    environment:
      DATABASE_URL: postgresql://rails_dev:abc123@db:5432/myapp_development
volumes:
  postgres_data:

Utwórz nową aplikację Rails:

docker-compose run --no-deps web rails new . --force --database=postgresql

Zaktualizuj config/database.yml:

development:
  <<: *default
  database: myapp_development
  username: rails_dev
  password: abc123
  host: db
  port: 5432

Uruchom migracje i serwer:

docker-compose run web rails db:setup
docker-compose run web rails db:migrate
docker-compose up

Otwórz przeglądarkę i odwiedź http://twoj_ip_serwera:3000.

Krok 1: Instalacja Ansible

Zainstaluj Ansible na lokalnym komputerze lub serwerze kontrolnym:

sudo dnf install -y epel-release
sudo dnf install -y ansible

Krok 2: Konfiguracja Ansible

Utwórz katalog projektu Ansible:

mkdir -p ~/ansible-rails
cd ~/ansible-rails

Utwórz plik inwentaryzacji hosts.yml:

all:
  hosts:
    rails_server:
      ansible_host: twoj_ip_serwera
      ansible_user: rocky
      ansible_ssh_private_key_file: ~/.ssh/id_rsa

Utwórz playbook deploy_rails.yml:

---
- name: Deploy Ruby on Rails with PostgreSQL
  hosts: rails_server
  become: yes
  tasks:
    - name: Update system
      dnf:
        name: "*"
        state: latest

    - name: Install prerequisites
      dnf:
        name: "{{ item }}"
        state: present
      loop:
        - curl
        - git
        - vim

    - name: Enable PostgreSQL module
      command: dnf module enable postgresql:12 -y

    - name: Install PostgreSQL
      dnf:
        name: "{{ item }}"
        state: present
      loop:
        - postgresql-server
        - postgresql-contrib
        - libpq-devel

    - name: Initialize PostgreSQL
      command: postgresql-setup --initdb
      args:
        creates: /var/lib/pgsql/data/postgresql.conf

    - name: Start and enable PostgreSQL
      systemd:
        name: postgresql
        state: started
        enabled: yes

    - name: Create PostgreSQL user
      become_user: postgres
      postgresql_user:
        name: rails_dev
        password: abc123
        state: present
        priv: CREATEDB

    - name: Configure pg_hba.conf
      lineinfile:
        path: /var/lib/pgsql/data/pg_hba.conf
        regexp: '^local\s+all\s+all\s+peer'
        line: 'local   all   all   md5'
        backrefs: yes
      notify: Restart PostgreSQL

    - name: Install RVM and Ruby
      shell: |
        curl -sSL https://rvm.io/mpapis.asc | gpg2 --import -
        curl -sSL https://rvm.io/pkuczynski.asc | gpg2 --import -
        curl -sSL https://get.rvm.io | bash -s stable
        source /etc/profile.d/rvm.sh
        rvm install ruby-3.1.1
        rvm use 3.1.1 --default
      args:
        executable: /bin/bash

    - name: Install Node.js and Yarn
      shell: |
        dnf module enable nodejs:14 -y
        dnf install -y nodejs npm
        npm install -g yarn
      args:
        executable: /bin/bash

    - name: Install Rails
      shell: |
        echo "export PATH=$PATH:/usr/local/bin" >> ~/.bashrc
        source ~/.bashrc
        gem install rails -v 7.0.4
      args:
        executable: /bin/bash

    - name: Create Rails app
      shell: |
        mkdir -p /var/www
        cd /var/www
        rails new myapp -d postgresql
      args:
        executable: /bin/bash

    - name: Configure database.yml
      copy:
        content: |
          development:
            <<: *default
            database: myapp_development
            username: rails_dev
            password: abc123
            host: localhost
            port: 5432
          test:
            <<: *default
            database: myapp_test
            username: rails_dev
            password: abc123
            host: localhost
            port: 5432
        dest: /var/www/myapp/config/database.yml

    - name: Run Rails migrations
      shell: |
        cd /var/www/myapp
        rails db:setup
        rails db:migrate
      args:
        executable: /bin/bash

  handlers:
    - name: Restart PostgreSQL
      systemd:
        name: postgresql
        state: restarted

Krok 3: Uruchomienie playbooka

Uruchom playbook Ansible:

ansible-playbook -i hosts.yml deploy_rails.yml

Krok 4: Uruchomienie serwera Rails

Po wykonaniu playbooka, zaloguj się na serwer przez SSH i uruchom serwer Rails:

cd /var/www/myapp
rails server -b 0.0.0.0 -p 3000

Otwórz przeglądarkę i odwiedź http://twoj_ip_serwera:3000.

Zabezpiecz swoje środowisko na serwerze VPS:

• • Zapora sieciowa: Skonfiguruj firewalld, aby zezwalać tylko na niezbędne porty:

sudo firewall-cmd --permanent --add-port=3000/tcp
sudo firewall-cmd --permanent --add-port=5432/tcp
sudo firewall-cmd --permanent --add-port=22/tcp
sudo firewall-cmd --reload

• • Ochrona SSH: Włącz uwierzytelnianie kluczem SSH i wyłącz logowanie roota w /etc/ssh/sshd_config:

sudo vim /etc/ssh/sshd_config
# Zmień:
# PermitRootLogin yes
# na:
PermitRootLogin no

Zrestartuj SSH:

sudo systemctl restart sshd

• Backupy: Skonfiguruj automatyczne backupy w panelu Netcloud24 (do 14 dni przechowywania danych).
• Ochrona DDoS: Netcloud24 zapewnia wbudowaną ochronę DDoS.

Zoptymalizuj swoje środowisko Rails:

• • Puma: Skonfiguruj serwer Puma w config/puma.rb:

workers 2
threads 5, 5

• • Cache: Włącz cache w config/environments/production.rb:

config.cache_store = :redis_cache_store, { url: "redis://localhost:6379/1" }

Zainstaluj Redis:

sudo dnf install -y redis
sudo systemctl start redis
sudo systemctl enable redis

• Skalowalność: Zwiększ zasoby w panelu Netcloud24, jeśli aplikacja wymaga większej mocy.

• Błędy połączenia z PostgreSQL? Sprawdź logi: sudo -u postgres psql -c "SELECT pg_last_error();".
• Problemy z Rails? Sprawdź logi w /var/www/myapp/log/development.log.
• Błędy Docker? Sprawdź status kontenerów: docker ps -a.
• Problemy z Ansible? Upewnij się, że klucz SSH jest poprawnie skonfigurowany: ssh-copy-id rocky@twoj_ip_serwera.
• Wolne działanie? Rozważ uaktualnienie planu na Netcloud24.