Come distribuire Ghost CMS su Rocky Linux 9

Su questa pagina

Prerequisiti
Passaggio 1: configurazione del firewall
Passaggio 2 - Installa Nginx
Passaggio 3 - Installa Node.js
Passaggio 4 - Installa MySQL
Passaggio 5 - Installa Ghost
1. Installa Ghost-CLI
2. Prepara la directory dei fantasmi
3. Installa Ghost
Ghost è una piattaforma di blogging open source che ti aiuta a creare un blog dall'aspetto professionale. È stato lanciato nel 2013 come alternativa a WordPress perché stava diventando eccessivamente complesso. È scritto in JavaScript ed è alimentato dalla libreria Node.js.
Questo tutorial esplorerà come installare Ghost CMS utilizzando Nginx e MySQL su un server alimentato da Rocky Linux 9. Useremo il server Nginx per ospitare il blog e il certificato SSL Lets Encrypt per proteggere la nostra installazione.
Prerequisiti
- A server running Rocky Linux 9.
- A non-root user with sudo privileges.
- A fully qualified domain name (FQDN) pointing to your server. For our purposes, we will use ghost.example.com as the domain name.
- Make sure everything is updated.
```
$ sudo dnf update
```
- Install basic utility packages. Some of them may already be installed.
```
$ sudo dnf install wget curl nano unzip yum-utils -y
```
Passaggio 1: configurare il firewall
Il primo passo è configurare il firewall. Rocky Linux utilizza Firewalld Firewall. Controlla lo stato dei firewall.
```
$ sudo firewall-cmd --state
running
```
Il firewall funziona con zone diverse e la zona pubblica è quella predefinita che utilizzeremo. Elenca tutti i servizi e le porte attive sul firewall.
```
$ sudo firewall-cmd --permanent --list-services
```
Dovrebbe mostrare il seguente output.
```
cockpit dhcpv6-client ssh
```
Wiki.js ha bisogno delle porte HTTP e HTTPS per funzionare. Aprili.
```
$ sudo firewall-cmd --add-service=http --permanent
$ sudo firewall-cmd --add-service=https --permanent
```
Ricarica il firewall per applicare le modifiche.
```
$ sudo firewall-cmd --reload
```
Passaggio 2: installa Nginx
Rocky Linux 9 viene fornito con una versione precedente di Nginx. Devi scaricare il repository Nginx ufficiale per installare l'ultima versione.
Crea e apri il file /etc/yum.repos.d/nginx.repo per creare il repository Nginx ufficiale.
```
$ sudo nano /etc/yum.repos.d/nginx.repo
```
Incolla il seguente codice al suo interno.
```
[nginx-stable]
name=nginx stable repo
baseurl=http://nginx.org/packages/centos/$releasever/$basearch/
gpgcheck=1
enabled=1
gpgkey=https://nginx.org/keys/nginx_signing.key
module_hotfixes=true

[nginx-mainline]
name=nginx mainline repo
baseurl=http://nginx.org/packages/mainline/centos/$releasever/$basearch/
gpgcheck=1
enabled=0
gpgkey=https://nginx.org/keys/nginx_signing.key
module_hotfixes=true
```
Salva il file premendo Ctrl + X e immettendo Y quando richiesto.
Installa il server Nginx.
```
$ sudo dnf install nginx -y
```
Verificare l'installazione.
```
$ nginx -v
nginx version: nginx/1.22.1
```
Abilita e avvia il server Nginx.
```
$ sudo systemctl enable nginx --now
```
Controlla lo stato del server.
```
$ sudo systemctl status nginx
? nginx.service - nginx - high performance web server
     Loaded: loaded (/usr/lib/systemd/system/nginx.service; enabled; vendor preset: disabled)
     Active: active (running) since Tue 2022-10-25 08:27:47 UTC; 2s ago
       Docs: http://nginx.org/en/docs/
    Process: 1650 ExecStart=/usr/sbin/nginx -c /etc/nginx/nginx.conf (code=exited, status=0/SUCCESS)
   Main PID: 1651 (nginx)
      Tasks: 2 (limit: 5912)
     Memory: 1.9M
        CPU: 7ms
     CGroup: /system.slice/nginx.service
             ??1651 "nginx: master process /usr/sbin/nginx -c /etc/nginx/nginx.conf"
             ??1652 "nginx: worker process"

Oct 25 08:27:47 ghost.example.com systemd[1]: Starting nginx - high performance web server...
```
Passaggio 3: installa Node.js
Ghost Installer ha bisogno di Nodejs per funzionare. Eseguire i seguenti comandi per installare Node 16.
```
$ curl -fsSL https://rpm.nodesource.com/setup_16.x | sudo bash -
```
Installa Node.
```
$ sudo dnf install -y nodejs
```
Verificare l'installazione del nodo.
```
$ node --version
v16.18.0
```
Al momento della stesura di questo tutorial, Node 18 è disponibile ed è la versione LTS. Ghost deve ancora aggiungere il supporto per questo. Tieni d'occhio il documento Ghost sulle versioni di Node per l'ultima versione di Node supportata. Quando Ghost aggiunge il supporto per Node 18, installa Node 18 utilizzando invece i seguenti comandi.
```
$ curl -fsSL https://rpm.nodesource.com/setup_18.x | sudo bash -
$ sudo dnf install -y nodejs
```
Passaggio 4: installa MySQL

Rocky Linux 9 viene fornito con l'ultima versione di MySQL. Puoi installarlo con un singolo comando.
```
$ sudo dnf install mysql-server
```
Controlla la versione di MySQL.
```
$ mysql --version
mysql  Ver 8.0.30 for Linux on x86_64 (Source distribution)
```
Abilita e avvia il servizio MySQL.
```
$ sudo systemctl enable mysqld --now
```
Controlla lo stato del servizio.
```
$ sudo systemctl status mysqld
? mysqld.service - MySQL 8.0 database server
     Loaded: loaded (/usr/lib/systemd/system/mysqld.service; enabled; vendor preset: disabled)
     Active: active (running) since Tue 2022-10-25 09:00:26 UTC; 3s ago
    Process: 2920 ExecStartPre=/usr/libexec/mysql-check-socket (code=exited, status=0/SUCCESS)
    Process: 2942 ExecStartPre=/usr/libexec/mysql-prepare-db-dir mysqld.service (code=exited, status=0/SUCCESS)
   Main PID: 3021 (mysqld)
     Status: "Server is operational"
      Tasks: 39 (limit: 5912)
     Memory: 404.4M
        CPU: 4.686s
     CGroup: /system.slice/mysqld.service
             ??3021 /usr/libexec/mysqld --basedir=/usr

Oct 25 09:00:18 ghost.example.com systemd[1]: Starting MySQL 8.0 database server...
Oct 25 09:00:18 ghost.example.com mysql-prepare-db-dir[2942]: Initializing MySQL database
Oct 25 09:00:26 ghost.example.com systemd[1]: Started MySQL 8.0 database server.
```
Puoi accedere alla shell MySQL utilizzando l'autenticazione Unix per impostazione predefinita. Ma non puoi eseguire la procedura guidata di configurazione della sicurezza. Pertanto, il passaggio seguente è necessario per le versioni MySQL 8.0.28 e successive. Entra nella shell MySQL.
```
$ sudo mysql
```
Esegui il seguente comando per impostare la password per il tuo utente root. Assicurati che contenga una combinazione di numeri, lettere maiuscole, minuscole e caratteri speciali.
```
mysql> ALTER USER 'root'@'localhost' IDENTIFIED WITH mysql_native_password BY 'YourPassword12!';
```
Esci dal guscio. L'avvertenza a questo passaggio è che non è più possibile accedere alla shell MySQL utilizzando l'autenticazione Unix.
```
mysql> exit
```
Esegui lo script di installazione sicura di MySQL.
```
$ sudo mysql_secure_installation
```
Ti verrà chiesto di installare il componente Validate Password. Controlla la forza delle password utilizzate in MySQL. Premi Y per installarlo.
```
Securing the MySQL server deployment.

Connecting to MySQL using a blank password.

VALIDATE PASSWORD COMPONENT can be used to test passwords
and improve security. It checks the strength of password
and allows the users to set only those passwords which are
secure enough. Would you like to setup VALIDATE PASSWORD component?

Press y|Y for Yes, any other key for No: Y
```
Successivamente, ti verrà chiesto di impostare il livello della politica di convalida della password. Scegli 2 in quanto è il più forte. Ti verrà quindi chiesto di creare una password di root. Inserisci una password con i requisiti indicati. E quando ti viene chiesto se vuoi continuare con la password, premi Y per procedere.
```
There are three levels of password validation policy:

LOW    Length >= 8
MEDIUM Length >= 8, numeric, mixed case, and special characters
STRONG Length >= 8, numeric, mixed case, special characters and dictionary                  file

Please enter 0 = LOW, 1 = MEDIUM and 2 = STRONG: 2
Please set the password for root here.

New password: 

Re-enter new password: 

Estimated strength of the password: 100 
Do you wish to continue with the password provided?(Press y|Y for Yes, any other key for No) : Y
```
Infine, premi Y per rimuovere gli utenti anonimi, non consentire gli accessi root remoti, rimuovere il database di test e ricaricare le tabelle dei privilegi.
```
By default, a MySQL installation has an anonymous user,
allowing anyone to log into MySQL without having to have
a user account created for them. This is intended only for
testing, and to make the installation go a bit smoother.
You should remove them before moving into a production
environment.

Remove anonymous users? (Press y|Y for Yes, any other key for No) : Y
Success.


Normally, root should only be allowed to connect from
'localhost'. This ensures that someone cannot guess at
the root password from the network.

Disallow root login remotely? (Press y|Y for Yes, any other key for No) : Y
Success.

By default, MySQL comes with a database named 'test' that
anyone can access. This is also intended only for testing,
and should be removed before moving into a production
environment.


Remove test database and access to it? (Press y|Y for Yes, any other key for No) : Y
 - Dropping test database...
Success.

 - Removing privileges on test database...
Success.

Reloading the privilege tables will ensure that all changes
made so far will take effect immediately.

Reload privilege tables now? (Press y|Y for Yes, any other key for No) : Y
Success.

All done!
```
Questo completa il processo di installazione e protezione di MySQL.
Passaggio 5: installa Ghost
L'installazione di Ghost comprenderà tre componenti: lo strumento a riga di comando Ghost-CLI che installa e gestisce gli aggiornamenti del blog Ghost e il pacchetto del blog stesso.
Installa Ghost-CLI
Eseguire il seguente comando per installare lo strumento Ghost-CLI. Ignora eventuali avvisi che ricevi durante il processo.
```
$ sudo npm install  -g
```
Prepara la directory fantasma
Crea la directory principale di Ghost.
```
$ sudo mkdir -p /var/www/html/ghost
```
Imposta la proprietà della directory sull'utente corrente.
```
$ sudo chown $USER:$USER /var/www/html/ghost
```
Imposta le autorizzazioni di directory corrette.
```
$ sudo chmod 755 /var/www/html/ghost
```
Passa alla directory Ghost.
```
$ cd /var/www/html/ghost
```
Installa Fantasma
L'installazione di Ghost è un processo a comando singolo.
```
$ ghost install
```
Durante l'installazione, lo strumento CLI porrà una serie di domande per configurare il blog.
- Al momento della stesura di questo tutorial, Ghost-CLI non supporta nessun altro sistema operativo oltre a Ubuntu. Ti chiederà se vuoi ancora continuare con l'installazione. Premi Y per continuare.
- URL del blog: inserisci l'URL completo del tuo blog insieme al protocollo https. (https://ghost.example.com)
- Nome host MySQL: premere Invio per utilizzare il valore predefinito di localhost poiché la nostra installazione di Ghost e MySQL si trovano sullo stesso server.
- Nome utente MySQL: inserisci root come nome utente MySQL.
- Password MySQL: inserisci la tua password di root creata in precedenza.
- Nome database Ghost: dai un nome al tuo database Ghost. (ghostdb)
- Password sudo: inserisci la password sudo del tuo sistema per eseguire comandi con privilegi elevati.
- Configurare un utente MySQL fantasma?: il programma di installazione chiederà se si desidera creare un utente MySQL separato per Ghost. Premi Y per procedere.
- Configurare Nginx?: in genere, Ghost-CLI rileva l'installazione di Nginx e la configura automaticamente per il tuo blog. Ma per ora, non è in grado di rilevare la nostra installazione di Nginx. Pertanto, il programma di installazione salterà automaticamente questo passaggio. Configureremo Nginx manualmente.
- Configurare SSL?: Poiché ha saltato la configurazione di Nginx, lo strumento CLI salterà anche la configurazione di un SSL.
- Set up systemd?: Ghost chiederà se si desidera configurare un servizio di sistema per Ghost. Premi Y per procedere.
- Avviare Ghost?: premere Y per avviare l'installazione di Ghost. Il servizio verrà avviato ma dovremo configurare Nginx e SSL per farlo funzionare.
Passaggio 6: installa SSL
Prima di procedere, dobbiamo installare lo strumento Certbot e un certificato SSL per il nostro dominio.
Per installare Certbot, utilizzeremo il programma di installazione del pacchetto Snapd. Snapd porta sempre con sé l'ultima versione stabile di Certbot, che dovresti usare.
Lo strumento Snapd richiede il repository Epel per funzionare.
```
$ sudo dnf install epel-release -y
```
Useremo Snapd per installare Certbot. Installa Snapd.
```
$ sudo dnf install snapd -y
```
Abilita e avvia il servizio Snap.
```
$ sudo systemctl enable snapd.socket --now
```
Crea i collegamenti necessari affinché Snapd funzioni.
```
$ sudo ln -s /var/lib/snapd/snap /snap
$ echo 'export PATH=$PATH:/var/lib/snapd/snap/bin' | sudo tee -a /etc/profile.d/snapd.sh
```
Assicurati che la tua versione di snapd sia aggiornata.
```
$ sudo snap install core 
$ sudo snap refresh core
```
Installa Cerbot.
```
$ sudo snap install --classic certbot
```
Utilizzare il seguente comando per assicurarsi che il comando Certbot possa essere eseguito creando un collegamento simbolico alla directory /usr/bin.
```
$ sudo ln -s /snap/bin/certbot /usr/bin/certbot
```
Genera un certificato SSL.
```
$ sudo certbot certonly --nginx --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m  -d ghost.example.com
```
Il comando precedente scaricherà un certificato nella directory /etc/letsencrypt/live/ghost.example.com sul tuo server.
Genera un certificato di gruppo Diffie-Hellman.
```
$ sudo openssl dhparam -dsaparam -out /etc/ssl/certs/dhparam.pem 4096
```
Esegui un'esecuzione a secco del processo per verificare se il rinnovo SSL funziona correttamente.
```
$ sudo certbot renew --dry-run
```
Se non vedi errori, sei a posto. Il tuo certificato si rinnoverà automaticamente.
Passaggio 7: configurare Nginx
Crea e apri il file /etc/nginx/conf.d/ghost.conf per la modifica.
```
$ sudo nano /etc/nginx/conf.d/ghost.conf
```
Incolla il seguente codice nel file ghost.conf. Sostituisci tutte le istanze di ghost.example.com con il tuo dominio.
```
## enforce HTTPS
server {
  listen 80;
  listen [::]:80;
  server_name ghost.example.com;
  return 301 https://$server_name$request_uri;
}

server {
  listen 443 ssl http2;
  listen [::]:443 ssl http2;
  server_name ghost.example.com;

  access_log /var/log/nginx/ghost.access.log;
  error_log /var/log/nginx/ghost.error.log;
  client_max_body_size 20m;

  http2_push_preload on; # Enable HTTP/2 Server Push

  ssl_certificate     /etc/letsencrypt/live/ghost.example.com/fullchain.pem;
  ssl_certificate_key /etc/letsencrypt/live/ghost.example.com/privkey.pem;
  ssl_trusted_certificate /etc/letsencrypt/live/ghost.example.com/chain.pem;
  ssl_session_timeout 1d;

  # Enable TLS versions (TLSv1.3 is required upcoming HTTP/3 QUIC).
  ssl_protocols TLSv1.2 TLSv1.3;

  # Enable TLSv1.3's 0-RTT. Use $ssl_early_data when reverse proxying to
  # prevent replay attacks.
  #
  # @see: https://nginx.org/en/docs/http/ngx_http_ssl_module.html#ssl_early_data
  ssl_early_data on;

  ssl_ciphers 'ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES256-SHA384:ECDHE-RSA-AES256-SHA384';
  ssl_prefer_server_ciphers on;
  ssl_ecdh_curve X25519:prime256v1:secp384r1:secp521r1;
  ssl_session_cache shared:SSL:50m;
  ssl_session_tickets off;

  # OCSP Stapling ---
  # fetch OCSP records from URL in ssl_certificate and cache them
  ssl_stapling on;
  ssl_stapling_verify on;
  ssl_dhparam /etc/ssl/certs/dhparam.pem;

  add_header X-Early-Data $tls1_3_early_data;

  location / {
    proxy_set_header Host $http_host;
    proxy_set_header X-Real-IP $remote_addr;
    proxy_set_header X-Forwarded-Proto https;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_pass http://localhost:2368;
  }
}

# This block is useful for debugging TLS v1.3. Please feel free to remove this
# and use the `$ssl_early_data` variable exposed by NGINX directly should you
# wish to do so.
map $ssl_early_data $tls1_3_early_data {
  "~." $ssl_early_data;
  default "";
}
```
La configurazione di cui sopra reindirizzerà tutte le richieste HTTP a HTTPS e fungerà da proxy per il servizio Ghost per servirlo tramite il tuo dominio.
Salva il file premendo Ctrl + X e immettendo Y quando richiesto.
Apri il file /etc/nginx/nginx.conf per la modifica.
```
$ sudo nano /etc/nginx/nginx.conf
```
Aggiungere la riga seguente prima della riga include /etc/nginx/conf.d/*.conf;.
```
server_names_hash_bucket_size  64;
```
Salva il file premendo Ctrl + X e immettendo Y quando richiesto.
Verifica la configurazione di Nginx.
```
$ sudo nginx -t
```
Se non vedi errori, significa che sei a posto. Ricarica il server Nginx.
```
$ sudo systemctl reload nginx
```
Passo 8 - Configura SELinux
Consenti a Nginx di connettersi alla rete.
```
$ sudo setsebool -P httpd_can_network_connect 1
```
Passaggio 9: eseguire il sito
Ora puoi verificare la tua installazione aprendo https://ghost.example.com nel tuo browser web. Otterrai la seguente pagina che indica un'installazione riuscita.
Passaggio 10: completare l'installazione
Per completare la configurazione del tuo blog Ghost, visita https://ghost.example.com/ghost nel tuo browser. L'extra /ghost alla fine del dominio del tuo blog ti reindirizza al pannello di amministrazione di Ghosts o, in questo caso, alla configurazione dal momento che stai accedendo per la prima volta.
Ti verrà richiesto di creare il tuo account amministratore e scegliere un titolo per il blog.
Inserisci i tuoi dati e fai clic sul pulsante Crea account e inizia a pubblicare per procedere.
Successivamente, verrai indirizzato alla schermata seguente, dove ti verranno fornite opzioni come scrivere il tuo primo post, personalizzare il tuo sito e importare membri.
Sceglieremo l'amministratore Explore Ghost da esplorare e andremo direttamente alla dashboard. Al termine della configurazione, verrai accolto con il pannello di amministrazione di Ghosts.
Se desideri passare alla modalità oscura, puoi farlo facendo clic sull'interruttore a levetta accanto al pulsante dell'ingranaggio delle impostazioni nella parte inferiore della pagina delle impostazioni.
Passa alla pagina Post e vedrai un post predefinito. Puoi annullare la pubblicazione o eliminarlo e iniziare a postare.
Passaggio 11: configurare Mailer
Ghost non funge solo da piattaforma di blog ma anche da gestore di newsletter. Per le operazioni quotidiane, puoi utilizzare qualsiasi servizio di posta transazionale per lavorare con Ghost per l'invio della posta. Ma se desideri inviare newsletter tramite Ghost, l'unico servizio di posta in blocco ufficiale supportato è Mailgun. Puoi anche utilizzare un servizio di newsletter diverso, ma per questo dovrai utilizzare la funzione di integrazione Zapier di Ghost.
Configuriamo prima un servizio SMTP per le email transazionali. Per questo apri il file /var/www/html/ghost/config.production.json per modificarlo.
```
$ nano /var/www/html/ghost/config.production.json
```
Trova le seguenti righe.
```
 "mail": {
    "transport": "Direct"
  },
```
Sostituiscili con il seguente codice.
```
"mail": {
    "from": "'Acme Support' ",
    "transport": "SMTP",
    "options": {
        "host": "YOUR-SES-SERVER-NAME",
        "port": 465,
        "service": "SES",
        "auth": {
            "user": "YOUR-SES-SMTP-ACCESS-KEY-ID",
            "pass": "YOUR-SES-SMTP-SECRET-ACCESS-KEY"
        }
    }
},
```
Qui stiamo utilizzando il servizio Amazon SES Mail poiché è molto economico e gratuito a vita se utilizzi il loro servizio EC2.
Se desideri utilizzare il loro servizio di newsletter utilizzando Mailgun, inserisci invece il seguente codice.
```
"mail": {
  "from": "'Acme Support' ",
  "transport": "SMTP",
  "options": {
    "service": "Mailgun",
    "host": "smtp.mailgun.org",
    "port": 587,
    "secure": true,
    "auth": {
      "user": "",
      "pass": "1234567890"
    }
  }
},
```
Salva il file premendo Ctrl + X e immettendo Y quando richiesto.
Al termine, riavviare l'applicazione Ghost per rendere effettive le modifiche.
```
$ ghost restart
```
Per configurare le impostazioni della newsletter, visita la sezione Impostazioni >> Email newsletter.
Fare clic sul collegamento di configurazione di Mailgun per espandere.
Inserisci la tua regione, il dominio e la chiave API di Mailgun.
Fare clic sul pulsante Salva in alto a destra per salvare le impostazioni.
Per testare la consegna della newsletter, apri qualsiasi post, apri le sue impostazioni e fai clic sull'opzione Email newsletter. Successivamente, invia un'e-mail di prova per verificare se funziona. Se non ricevi errori, significa che la consegna della tua newsletter sta funzionando.
Passaggio 12: aggiorna Ghost
Esistono due tipi di aggiornamenti di Ghost: aggiornamenti minori e aggiornamenti principali.
Innanzitutto, esegui un backup completo se desideri eseguire un aggiornamento minore.
```
$ cd /var/www/html/ghost
$ ghost backup
```
Eseguire il comando update per eseguire l'aggiornamento minore.
```
$ ghost update
```
Per eseguire un aggiornamento importante, è necessario seguire la guida di aggiornamento dettagliata ufficiale su Ghost. A seconda della versione in cui ti trovi attualmente e della versione principale a cui desideri eseguire l'aggiornamento, i passaggi variano.
Conclusione
Questo conclude il nostro tutorial su come configurare Ghost CMS sul tuo server Rocky Linux 9 usando Nginx. Se hai domande o feedback, condividili nei commenti qui sotto.

Come distribuire Ghost CMS su Rocky Linux 9

Su questa pagina

Prerequisiti

Passaggio 1: configurare il firewall

Passaggio 2: installa Nginx

Passaggio 3: installa Node.js

Passaggio 4: installa MySQL

Passaggio 5: installa Ghost

Installa Ghost-CLI

Prepara la directory fantasma

Installa Fantasma

Passaggio 6: installa SSL

Passaggio 7: configurare Nginx

Passo 8 - Configura SELinux

Passaggio 9: eseguire il sito

Passaggio 10: completare l'installazione

Passaggio 11: configurare Mailer

Passaggio 12: aggiorna Ghost

Conclusione