Ricerca nel sito web

Come installare Ghost CMS con Docker su Ubuntu 20.04


Su questa pagina

  1. Prerequisiti
  2. Passaggio 1: configurazione del firewall UFW
  3. Passaggio 2 - Installa Certbot e ottieni il certificato SSL
  4. Passaggio 3 - Installa Docker e Docker Compose
  5. Passaggio 4 - Installa Ghost
    1. Crea file di composizione Docker
    2. Crea l'immagine Docker di Nginx

    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. Ghost è scritto in JavaScript ed è alimentato da Node.js.

    In questo tutorial, esploreremo come installare Ghost CMS utilizzando Docker su un server basato su Ubuntu 20.04. Useremo anche Nginx come proxy e il certificato Lets Encrypt SSL per proteggere la nostra installazione.

    Prerequisiti

    • A server running Ubuntu 20.04.

    • A non-root sudo user.

    • Make sure everything is updated.

      $ sudo apt update 
      $ sudo apt upgrade
      

    Passaggio 1: configurare il firewall UFW

    Il primo passo è configurare il firewall. Ubuntu viene fornito con ufw (Uncomplicated Firewall) per impostazione predefinita.

    Controlla se il firewall è in esecuzione.

    $ sudo ufw status
    

    Dovresti ottenere il seguente output.

    Status: inactive
    

    Consenti porta SSH in modo che il firewall non interrompa la connessione corrente attivandola.

    $ sudo ufw allow OpenSSH
    

    Consenti anche porte HTTP e HTTPS.

    $ sudo ufw allow 80
    $ sudo ufw allow 443
    

    Abilita il firewall

    $ sudo ufw enable
    Command may disrupt existing ssh connections. Proceed with operation (y|n)? y
    Firewall is active and enabled on system startup
    

    Controlla di nuovo lo stato del firewall.

    $ sudo ufw status
    

    Dovresti vedere un output simile.

    Status: active
    
    To                         Action      From
    --                         ------      ----
    OpenSSH                    ALLOW       Anywhere
    80                         ALLOW       Anywhere
    443                        ALLOW       Anywhere
    OpenSSH (v6)               ALLOW       Anywhere (v6)
    80 (v6)                    ALLOW       Anywhere (v6)
    443 (v6)                   ALLOW       Anywhere (v6)
    

    Passo 2 - Installa Certbot e ottieni il certificato SSL

    Prima di procedere, dobbiamo installare lo strumento Certbot e installare un certificato SSL per il nostro dominio.

    Per installare Certbot, utilizzeremo il programma di installazione del pacchetto Snapd. Il repository ufficiale di Certbots è stato deprecato e il pacchetto Ubuntus Certbot ha più di un anno. Snapd porta sempre con sé l'ultima versione stabile di Certbot e dovresti usarla. Fortunatamente, Ubuntu 20.04 viene fornito con Snapd preinstallato.

    Assicurati che la tua versione di Snapd sia aggiornata.

    $ sudo snap install core 
    $ sudo snap refresh core
    

    Rimuovi tutte le vecchie versioni di Certbot.

    $ sudo apt remove certbot
    

    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 --standalone -d example.com
    

    Il comando precedente scaricherà un certificato nella directory /etc/letsencrypt/live/example.com sul tuo server.

    Passaggio 3: installa Docker e Docker Compose

    Il primo passo è installare Docker Engine e Docker Compose. Innanzitutto, disinstalla tutte le versioni precedenti di Docker.

    $ sudo apt remove docker docker-engine docker.io containerd runc
    

    Installa alcuni pacchetti necessari per l'esecuzione di Docker.

    $ sudo apt install apt-transport-https ca-certificates curl gnupg lsb-release
    

    Aggiungi la chiave GPG ufficiale di Dockers.

    $ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg
    

    Aggiungi il repository ufficiale di Dockers.

    $ echo "deb [arch=amd64 signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
    

    Aggiorna i repository di sistema.

    $ sudo apt update
    

    Installa l'ultima versione di Docker Engine.

    $ sudo apt install docker-ce docker-ce-cli containerd.io
    

    Verificare che Docker Engine sia in esecuzione e installato correttamente.

    $ sudo docker run hello-world
    

    Per impostazione predefinita, Docker richiede l'esecuzione di sudo. Per ovviare a questo, possiamo aggiungere l'account utente corrente al gruppo utenti docker.

    $ sudo usermod -aG docker ${USER}
    

    Per applicare la nuova appartenenza al gruppo, disconnettersi e riconnettersi oppure utilizzare il seguente comando.

    $ su - ${USER}
    

    Ora puoi eseguire i comandi docker senza usare sudo.

    Successivamente, scarica l'attuale versione stabile di Docker compose.

    sudo curl -L "https://github.com/docker/compose/releases/download/1.28.6/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
    

    Al momento della stesura di questo tutorial, 1.28.6 è l'ultima versione di Docker compose. Puoi sempre modificare o scegliere una versione diversa nel comando controllando dalla pagina delle versioni di Github di Docker compose.

    Applicare l'autorizzazione eseguibile alla versione installata di Docker compose.

    $ sudo chmod +x /usr/local/bin/docker-compose
    

    Testare l'installazione.

    $ docker-compose --version
    docker-compose version 1.28.6, build 5db8d86f
    

    Passaggio 4: installa Ghost

    L'installazione di Ghost comprenderà tre componenti: pacchetto Ghost, un server di database come MySQL e un server Web (Nginx). Tutti questi servizi possono essere installati utilizzando un singolo file di composizione Docker.

    Crea file di composizione Docker

    Innanzitutto, crea una directory in cui archiviare e avviare il tuo file di composizione Docker.

    $ mkdir ghost && cd ghost
    

    Crea un file chiamato docker-compose.yml e aprilo con l'editor Nano.

    $ nano docker-compose.yml
    

    Incollare il seguente codice nel file. Sostituisci example.com con il tuo dominio e inserisci una password del database al posto del valore tua_password. Mantieni gli stessi valori per database__connection__password e MYSQL_ROOT_PASSWORD. Sostituisci <username> con il nome utente del tuo server.

    version: '3.3'
    services:
    
      ghost:
        image: ghost:latest
        restart: always
        depends_on:
          - db
        environment:
          url: https://example.com
          database__client: mysql
          database__connection__host: db
          database__connection__user: ghost
          database__connection__password: ghostdbpass
          database__connection__database: ghostdb
          mail__transport: SMTP
          mail__options__host: {Your Mail Service host}
          mail__options__port: {Your Mail Service port}
          mail__options__secureConnection: {true/false}
          mail__options__service: {Your Mail Service}
          mail__options__auth__user: {Your User Name}
          mail__options__auth__pass: {Your Password}
        volumes:
          - /home/<username>/ghost/content:/var/lib/ghost/content
    
      db:
        image: mariadb:latest
        restart: always
        environment:
          MYSQL_ROOT_PASSWORD: your_mysql_root_password
    	  MYSQL_USER: ghost
          MYSQL_PASSWORD: ghostdbpass
          MYSQL_DATABASE: ghostdb
        volumes:
          - /home/<username>/ghost/mysql:/var/lib/mysql
    
      nginx:
        build:
          context: ./nginx
          dockerfile: Dockerfile
        restart: always
        depends_on:
          - ghost
        ports:
          - "80:80"
          - "443:443"
        volumes:
          - /etc/letsencrypt/:/etc/letsencrypt/
          - /usr/share/nginx/html:/usr/share/nginx/html
    

    Il file di composizione Docker crea alcuni punti di montaggio, ovvero esegue il mapping di determinate directory sul server alle directory all'interno del contenitore.

    • Le directory /var/lib/ghost/content e /var/lib/mysql all'interno dei contenitori sono mappate su /home// ghost/content e /home//ghost/mysql sul server.
    • Nginx usa il bind /etc/letsencrypt/ per accedere ai certificati Lets Encrypt dal server.
    • Nginx necessita anche dell'accesso alla directory utente /usr/share/nginx/html in modo che possa accedere ai file Lets Encrypt Challenge per il certificato.

    Nel file sopra, abbiamo incluso anche le opzioni per impostare la posta. Se stai utilizzando un popolare servizio di posta SMTP come Mailgun, Mailjet, Mandrill, Postmark, Sendgrid, SendCloud, SES, Zoho o Gmail, puoi semplicemente aggiungere il nome del servizio e il tuo nome utente e password SMTP e farla finita con il resto i campi. Altrimenti, riempi tutte le altre opzioni e rimuovi il nome del servizio e dovrebbe ancora funzionare. Puoi controllare più opzioni di posta nella documentazione di Ghosts sulle opzioni di posta.

    Crea directory per tutti i bind mount descritti sopra (ad eccezione di /etc/letsencrypt, che era già stato creato quando abbiamo creato il certificato in precedenza)

    $ cd ~/ghost
    $ mkdir content
    $ mkdir mysql
    $ sudo mkdir -p /usr/share/nginx/html
    

    Crea l'immagine Docker di Nginx

    Il file di composizione Docker che abbiamo creato si basa sull'immagine Nginx Docker. Per farlo funzionare, dobbiamo includere un file di configurazione personalizzato per Nginx che funzionerà con Ghost.

    Crea una directory per questa immagine nella directory corrente.

    $ mkdir nginx
    

    Crea un file chiamato Dockerfile in questa directory.

    $ touch nginx/Dockerfile
    

    Incolla il seguente codice nel Dockerfile.

    FROM nginx:latest
    RUN rm /etc/nginx/conf.d/default.conf
    COPY ghost.conf /etc/nginx/conf.d
    

    Il codice precedente indica a Docker di utilizzare l'ultima immagine Nginx. Elimina anche il file di configurazione Nginx predefinito e copia il file di configurazione personalizzato che abbiamo creato per il nostro Ghost CMS.

    Crea un file chiamato ghost.conf nella directory nginx.

    $ touch nginx/ghost.conf
    

    Incolla il seguente codice nel file ghost.conf. Sostituisci tutte le istanze di example.com con il tuo dominio.

    server {
      listen 80;
      listen [::]:80;
      server_name example.com;
      # Useful for Let's Encrypt
      location /.well-known/acme-challenge/ { root /usr/share/nginx/html; allow all; }
      location / { return 301 https://$server_name$request_uri; }
    }
    
    server {
      listen 443 ssl http2;
      listen [::]:443 ssl http2;
      server_name example.com;
        
      access_log /var/log/nginx/ghost.access.log;
      error_log /var/log/nginx/ghost.error.log;
      client_max_body_size 20m;
    
      ssl_protocols TLSv1.2 TLSv1.3;
      ssl_ciphers ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384;
      ssl_prefer_server_ciphers on;
      ssl_session_timeout 1d;
      ssl_session_cache shared:SSL:10m;
    
      ssl_certificate     /etc/letsencrypt/live/example.com/fullchain.pem;
      ssl_certificate_key /etc/letsencrypt/live/example.com/privkey.pem;
    
      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://ghost:2368;
      }
    }
    

    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.

    Passaggio 5: eseguire il sito

    Esegui il seguente comando dalla directory ghost per avviare il servizio Ghost.

    $ docker-compose up -d
    

    Ora puoi verificare la tua installazione aprendo https://example.com nel tuo browser web. Potrebbero essere necessari diversi minuti prima che Docker attivi tutti i servizi, quindi potrebbe essere necessario aggiornare se non vedi subito il tuo blog.

    Se il tuo sito non viene visualizzato nel browser, devi rivedere i log di Docker. Per farlo, chiudi prima il contenitore.

    $ cd ghost
    $ docker-compose down
    

    Esegui Docker compose in uno stato collegato per visualizzare i log generati da ciascun contenitore.

    $ docker-compose up
    

    Per chiudere il contenitore e tornare al prompt di bash, premi CTRL+C. Una volta terminata la risoluzione dei problemi, puoi eseguire nuovamente il contenitore e questa volta il tuo blog dovrebbe essere visibile.

    Passaggio 6: completare l'installazione

    Per completare la configurazione del tuo blog Ghost, visita https://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.

    Qui, ti verrà richiesto di creare il tuo account amministratore e scegliere un titolo per il blog.

    Puoi anche invitare altri membri dello staff o collaboratori per il tuo blog, cosa che puoi fare anche in seguito se scegli di saltare ora.

    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.

    Vedrai già alcuni post predefiniti che sono fondamentalmente guide per aiutarti a navigare e utilizzare Ghost. Puoi annullare la pubblicazione o eliminarli e iniziare a pubblicare.

    Passaggio 7: aggiorna Ghost

    Nel nostro file di composizione Docker, stiamo estraendo l'ultima versione di Ghost disponibile al momento dell'installazione, il che semplifica l'aggiornamento del tuo blog Ghost.

    Per eseguire l'aggiornamento, devi chiudere il contenitore, richiamare le immagini più recenti e quindi eseguire nuovamente il contenitore.

    $ docker-compose down
    $ docker-compose pull && docker-compose up -d
    

    Passo 8 - Rinnova il tuo certificato SSL Lets Encrypt

    I certificati Lets Encrypt sono validi solo per 90 giorni. Pertanto, dobbiamo impostare un cronjob che rinnoverà automaticamente il certificato.

    Apri Crontab nel tuo editor.

    $ sudo crontab -e
    

    Incolla la seguente riga alla fine che eseguirà Certbot ogni giorno alle 23:00. Sostituisci example.com con il tuo dominio.

    0 23 * * *   certbot certonly -n --webroot -w /usr/share/nginx/html -d example.com --deploy-hook='docker exec ghost_nginx_1 nginx -s reload'
    

    L'esecuzione ogni giorno alle 23:00 non significa che il tuo certificato verrà rinnovato ogni giorno poiché Certbot rinnoverà il tuo certificato solo se la sua data di scadenza è entro 30 giorni. L'esecuzione di questo ogni notte offre allo script una serie di possibilità di provare prima della scadenza.

    Il comando precedente riavvierà anche il server Nginx all'interno del contenitore Docker dopo il rinnovo riuscito.

    Puoi testare il cronjob usando l'opzione --dry-run di Certbot.

    $ sudo bash -c "certbot certonly -n --webroot --dry-run -w /usr/share/nginx/html -d example.com --deploy-hook='docker exec ghost_nginx_1 nginx -s reload'"
    

    Conclusione

    Questo conclude il nostro tutorial su come configurare Ghost CMS sul tuo server basato su Ubuntu 20.04 usando Docker. Se hai domande o feedback, condividili nei commenti qui sotto.