Jak zainstalować SolidInvoice 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 SolidInvoice, wydajnego i otwartego oprogramowania do fakturowania i zarządzania klientami. 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 do obsługi Twojej firmy.

Wprowadzenie do SolidInvoice i nasza filozofia konfiguracji

SolidInvoice to darmowe, oparte na Symfony, oprogramowanie do zarządzania fakturami i klientami. Jest to idealne rozwiązanie dla freelancerów i małych firm, które chcą mieć pełną kontrolę nad swoimi danymi i procesem fakturowania bez opłat abonamentowych. Aby wdrożyć SolidInvoice w środowisku produkcyjnym, najbezpieczniejszym i najbardziej powtarzalnym sposobem jest użycie Dockera, który pakuje wszystkie niezbędne zależności (aplikację, bazę danych, serwer webowy) w spójne kontenery.

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)

Do instalacji SolidInvoice wykorzystamy Dockera i Docker Compose. Poniżej znajdują się instrukcje instalacji Dockera na wspieranych systemach.

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 SolidInvoice

Użyjemy Docker Compose do zdefiniowania wszystkich usług potrzebnych do uruchomienia SolidInvoice: kontener PHP-FPM, serwer webowy Nginx, serwer baz danych (MariaDB) oraz serwer Redis do cache'owania. Kontener Certbot zostanie wykorzystany do automatycznej obsługi certyfikatów SSL.

mkdir -p ~/solidinvoice
cd ~/solidinvoice

Pobierz najnowszą wersję SolidInvoice (z Githuba lub oficjalnej strony) i umieść pliki w katalogu `solidinvoice_app`.

version: '3.8'

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

  php:
    build:
      context: .
      dockerfile: Dockerfile.php
    volumes:
      - ./solidinvoice_app:/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
      - ./solidinvoice_app/public:/var/www/html:ro # SolidInvoice używa katalogu public/
      - ./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

volumes:
  db_data:
  certbot_conf:
  certbot_www:

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

Utwórz Nginx site config (./nginx/conf.d/solidinvoice.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;
    
    location / {
        try_files $uri /index.php$is_args$args;
    }

    location ~ \.php$ {
        fastcgi_pass php:9000;
        fastcgi_index index.php;
        include fastcgi_params;
        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
    }
}

Uruchom kontenery i wygeneruj certyfikaty, jak w poprzednich artykułach.

Krok 4: Automatyzacja z Ansible

Ansible może zautomatyzować cały proces wdrażania SolidInvoice, od instalacji Dockera po uruchomienie aplikacji. Zapewnia to spójność i powtarzalność.

# inventory.ini
[solidinvoice_servers]
your_server_ip ansible_user=your_ssh_user

# playbook.yml
---
- name: Deploy SolidInvoice with Docker
  hosts: solidinvoice_servers
  become: yes
  vars:
    app_root: /opt/solidinvoice
    domain_name: yourdomain.com
    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: "{{ app_root }}/{{ item }}"
        state: directory
        mode: '0755'
      loop:
        - "solidinvoice_app"
        - "php"
        - "nginx/conf.d"
        - "certbot/conf"
        - "certbot/www"

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

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

Krok 5: Orkiestracja z Kubernetes (dla zaawansowanych)

W przypadku dużych, skalowalnych wdrożeń, Kubernetes jest optymalnym wyborem. Pozwala na orkiestrację kontenerów, automatyczne skalowanie i zapewnienie wysokiej dostępności. Twoja aplikacja SolidInvoice, 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: solidinvoice-app
spec:
  replicas: 2
  selector:
    matchLabels:
      app: solidinvoice-app
  template:
    metadata:
      labels:
        app: solidinvoice-app
    spec:
      containers:
      - name: solidinvoice-php
        image: your-custom-php-image:latest
        env:
        - name: DATABASE_URL
          value: "mysql://solidinvoice_user:db_password@solidinvoice-db-service/solidinvoice_db"
        ports:
        - containerPort: 9000
---
apiVersion: v1
kind: Service
metadata:
  name: solidinvoice-app-service
spec:
  selector:
    app: solidinvoice-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 `solidinvoice-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" "solidinvoice_server" {
  ami           = "ami-0abcdef1234567890" # Zmień na odpowiednie AMI dla Twojej dystrybucji
  instance_type = "t3.medium"
  key_name      = "my-ssh-key"
  tags = {
    Name = "SolidInvoice-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.