Jak zainstalować Fuel CMS z Nginx i Let's Encrypt SSL na serwerze Linux (Ubuntu 22.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 Fuel CMS, wydajnego systemu zarządzania treścią opartego na frameworku CodeIgniter. 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 bezpieczne środowisko dla Twojej strony internetowej.

Wprowadzenie do Fuel CMS i nasza filozofia konfiguracji

Fuel CMS to elastyczny i wydajny system zarządzania treścią, który łączy w sobie potęgę frameworku CodeIgniter z intuicyjnym interfejsem administracyjnym. Jest to idealne rozwiązanie dla deweloperów i agencji, którzy potrzebują pełnej kontroli nad kodem i strukturą bazy danych, a jednocześnie chcą dostarczyć klientom łatwe w obsłudze narzędzie do zarządzania treścią. W tym przewodniku pokażemy, jak wdrożyć Fuel CMS na popularnych dystrybucjach Linux, zabezpieczając go za pomocą Nginx i darmowego certyfikatu SSL od Let's Encrypt.

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

Dla Rocky Linux 9 / AlmaLinux / CentOS:

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

Krok 2: Instalacja Dockera (dla wszystkich dystrybucji)

Docker jest doskonałym narzędziem do konteneryzacji aplikacji webowych, takich jak Fuel CMS, ze względu na ich liczne zależności (PHP, Nginx, baza danych). Zapewnia to spójne i izolowane środowisko.

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 3: Konfiguracja Docker Compose dla Fuel CMS

Stworzymy plik docker-compose.yml, który zdefiniuje całe nasze środowisko: serwer baz danych (MySQL/MariaDB), kontener PHP-FPM z Fuel CMS, serwer proxy Nginx oraz kontener Certbot do automatycznej obsługi certyfikatów SSL.

mkdir -p ~/fuelcms
cd ~/fuelcms

Pobierz i rozpakuj najnowszą wersję Fuel CMS (upewnij się, że jest to wersja kompatybilna z PHP 8.2).

# Pobierz i rozpakuj pliki Fuel CMS do katalogu fuel_cms
# Instrukcje znajdziesz na stronie Fuel CMS

Utwórz docker-compose.yml:

version: '3.8'

services:
  db:
    image: mariadb:10.6
    restart: always
    environment:
      MARIADB_ROOT_PASSWORD: your_root_password
      MARIADB_DATABASE: fuel_cms_db
      MARIADB_USER: fuel_cms_user
      MARIADB_PASSWORD: your_db_password
    volumes:
      - db_data:/var/lib/mysql

  php:
    build:
      context: .
      dockerfile: Dockerfile.php
    volumes:
      - ./fuel_cms:/var/www/html
      - ./php/custom.ini:/usr/local/etc/php/conf.d/custom.ini
    depends_on:
      - db
    restart: always

  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
      - ./fuel_cms:/var/www/html:ro
      - ./certbot/conf:/etc/letsencrypt:ro
      - ./certbot/www:/var/www/certbot:ro
    depends_on:
      - php
    restart: always

  certbot:
    image: certbot/certbot
    volumes:
      - ./certbot/conf:/etc/letsencrypt
      - ./certbot/www:/var/www/certbot
    # Zostaw to puste, uruchomimy to ręcznie w pierwszym kroku.

volumes:
  db_data:
  certbot_conf:
  certbot_www:

Utwórz Nginx site config (./nginx/conf.d/fuelcms.conf, zmień yourdomain.com):

server {
    listen 80;
    server_name yourdomain.com www.yourdomain.com;
    
    location /.well-known/acme-challenge/ {
        root /var/www/certbot;
    }
    
    location / {
        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;
    index index.php index.html index.htm;
    
    location / {
        try_files $uri $uri/ /index.php$is_args$args;
    }

    location ~ \.php$ {
        try_files $uri =404;
        fastcgi_split_path_info ^(.+\.php)(/.+)$;
        fastcgi_pass php:9000;
        fastcgi_index index.php;
        include fastcgi_params;
        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
        fastcgi_param PATH_INFO $fastcgi_path_info;
    }
}

Utwórz Dockerfile dla PHP (Dockerfile.php):

FROM php:8.2-fpm-alpine

RUN apk add --no-cache \
    git \
    libzip-dev \
    libjpeg-turbo-dev \
    libpng-dev \
    mariadb-connector-c-dev

RUN docker-php-ext-install pdo pdo_mysql opcache zip \
    && docker-php-ext-enable opcache

WORKDIR /var/www/html

Instalacja certyfikatów SSL Let's Encrypt:

# Upewnij się, że Nginx jest uruchomiony, aby Certbot mógł działać
docker compose up -d nginx

# Wygeneruj certyfikaty (zmień email i domenę)
docker compose run --rm certbot certonly --webroot -w /var/www/certbot \
  -d yourdomain.com -d www.yourdomain.com \
  --email [email protected] --agree-tos --no-eff-email

# Zatrzymaj Nginx i uruchom wszystkie usługi
docker compose down nginx
docker compose up -d

Następnie możesz przejść do swojej domeny w przeglądarce i dokończyć instalację Fuel CMS.

Krok 4: Automatyzacja z Ansible

Ansible może zautomatyzować cały proces wdrażania Fuel CMS, od instalacji Dockera po uruchomienie aplikacji. Zapewnia to spójność i powtarzalność w procesie wdrażania na wielu serwerach.

# inventory.ini
[fuelcms_servers]
your_server_ip ansible_user=your_ssh_user

# playbook.yml
---
- name: Deploy Fuel CMS with Docker
  hosts: fuelcms_servers
  become: yes
  vars:
    domain_name: yourdomain.com
    db_root_password: "YourStrongRootPassword"
    db_password: "YourStrongDbPassword"
    certbot_email: "[email protected]"

  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'
    
    # ... (kod instalacji Dockera, jak w poprzednich artykułach) ...
    
    - name: Utworzenie katalogów projektu
      file:
        path: "/opt/fuelcms/{{ item }}"
        state: directory
        mode: '0755'
      loop:
        - "fuel_cms"
        - "php"
        - "nginx/conf.d"
        - "certbot/conf"
        - "certbot/www"

    - name: Pobranie i rozpakowanie Fuel CMS
      # ... (tutaj umieść zadanie pobrania i rozpakowania, np. unarchive) ...
    
    - name: Kopiowanie plików konfiguracyjnych
      template:
        src: "./templates/{{ item }}.j2"
        dest: "/opt/fuelcms/{{ item }}"
      loop:
        - docker-compose.yml
        - php/custom.ini
        - nginx/conf.d/fuelcms.conf

    - name: Uruchomienie aplikacji za pomocą Docker Compose
      community.docker.docker_compose:
        project_src: "/opt/fuelcms"
        state: present

Krok 5: Orkiestracja z Kubernetes (dla zaawansowanych)

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

Oto uproszczona koncepcja wdrożenia na Kubernetes:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: fuelcms-app
spec:
  replicas: 2
  selector:
    matchLabels:
      app: fuelcms-app
  template:
    metadata:
      labels:
        app: fuelcms-app
    spec:
      containers:
      - name: fuelcms-php
        image: your-custom-php-image:latest
        env:
        - name: DB_HOST
          value: "fuelcms-db-service"
        - name: DB_NAME
          value: "fuel_cms_db"
        - name: DB_USER
          value: "fuel_cms_user"
        - name: DB_PASSWORD
          valueFrom:
            secretKeyRef:
              name: fuelcms-secrets
              key: db-password
        ports:
        - containerPort: 9000
---
apiVersion: v1
kind: Service
metadata:
  name: fuelcms-app-service
spec:
  selector:
    app: fuelcms-app
  ports:
    - port: 9000
      targetPort: 9000
  type: ClusterIP

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

Krok 6: 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 22.04:

resource "aws_instance" "fuelcms_server" {
  ami           = "ami-0abcdef1234567890" # Zmień na odpowiednie AMI dla Twojej dystrybucji
  instance_type = "t3.medium"
  key_name      = "my-ssh-key"
  tags = {
    Name = "FuelCMS-Server"
  }
}

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