Come automatizzare il deploy di una applicazione Node.js con Shipit su CentOS 7

Shipit è uno strumento in grado di configurare il deploy su server remoti di applicazioni Node.js. Attraverso l’utilizzo di Orchestrator e altri pacchetti come OpenSSH ti permette di configurare dei task automatici, permettendoti di gestire al meglio la pubblicazione delle tue applicazione Node.js.

In questo tutorial vedremo come configurare un processo automatico per trasferire un'applicazione di esempio dalla tua macchina locale al server remoto, utilizzando il tool di sviluppo Shipit.

Prerequisiti

Per iniziare dovrai connetterti al tuo server tramite una connessione SSH. Se non l’hai ancora fatto, ti consigliamo di seguire la nostra guida per connetterti in sicurezza con il protocollo SSH. In caso di server locale puoi passare al punto successivo e aprire il terminale del tuo server.

Prima di procedere allo sviluppo della nostra applicazione di esempio, è necessario che sulla tua macchina siano installati Git e Node.js. Se necessario, visita le nostre guide su come installare Git e su come installare Node.js per maggiori informazioni.

Creazione del repository su GitHub

Shipit permette di sincronizzare un repository Git da una macchina di sviluppo a un server remoto: in questo esempio utilizzeremo il servizio fornito da github.com per creare il nostro repository e permetterne la sincronizzazione.

Nel caso in cui tu non voglia utilizzare github.com, i comandi utilizzati nella seguente guida sono compatibili con qualsiasi repository remoto Git.

Per creare il tuo repository visita il seguente url:

https://github.com/new

Compila i campi richiesti dal sito, utilizzando come “Repository name” un testo non contenente spazi o caratteri speciali: in questo tutorial utilizzeremo “shipit-test”.

Una volta completato, utilizza il pulsante “Create repository” per completare l’operazione.

Creazione del progetto

Utilizzando la tua macchina puoi procedere a clonare il repository appena creato attraverso il comando indicato sotto, sostituendo i campi indicati:

git clone [email protected]:[NOME_UTENTE_GIT]/[NOME_REPO].git

Nel nostro caso sarà:

git clone [email protected]:shipit-user/shipit-test.git

Quindi entra dentro la cartella appena creata e inizializza un progetto vuoto con npm:

cd shipit-test

npm init -y

Procedi installando il framework Express e le dipendenze Shipit:

npm i --save express

npm i --save-dev shipit-cli shipit-deploy shipit-shared

A questo punto puoi creare un’applicazione di esempio, per verificare il corretto funzionamento di Shipit. In questo tutorial utilizzeremo il template “Hello world” di Express:

const express = require('express')
const app = express()
const port = 3000

app.get('/', (req, res) => {
  res.send('Hello World!')
})

app.listen(port, '0.0.0.0', () => {
  console.log(`Example app listening at http://localhost:${port}`)
})

Salva il listato indicato sopra in nuovo file chiamato “index.js” utilizzando il tuo editor di testo preferito.

Continua quindi creando un secondo file, chiamato “shipitfile.js” con il seguente contenuto:

module.exports = shipit => {
  // Load shipit-deploy tasks
  require('shipit-deploy')(shipit)

  shipit.initConfig({
    default: {
      deployTo: '/var/node/shipit-test',
      repositoryUrl: 'https://github.com/[NOME_UTENTE_GITHUB]/[NOME_REPO].git',
    },
    staging: {
      servers: 'deploy@[INDIRIZZO_IP_SERVER_REMOTO]',
    },
  })
}

Cambia opportunamente i campi indicati sopra con il nome del tuo utente GitHub, il nome del repository creato precedentemente e l’indirizzo del server remoto.

Aggiungi i file appena creati al repository Git tramite il comando:

git add index.js shipitfile.js package.json

Quindi procedi a creare un commit e inviare la modifiche:

git commit -m "Setup"
git push -u origin master

Configurazione del server in produzione

Completati i passaggi indicati sopra, puoi procedere alla configurazione del server remoto dove andrai a effettuare il deploy della tua applicazione.

Per prima cosa devi procedere con l’installazione di rsync, un pacchetto richiesto da Shipit per effettuare le sincronizzazione dei file tra la tua macchina di sviluppo e quella di produzione:

yum install rsync -y

Procedi quindi creando un utente unix che andrai ad utilizzare tramite ShipIt per effettuare il deploy:

useradd --shell /usr/bin/bash deploy

Imposta una password per l’utente appena creato:

passwd deploy

Quindi crea una cartella dove effettuare il deploy e assegna i permessi per l’utente appena creato:

mkdir /var/node

chown deploy:deploy /var/node

Puoi quindi installare l’ultima versione di Node.js tramite i comandi:

curl -sL https://rpm.nodesource.com/setup_12.x | sudo bash -

yum install nodejs -y

Puoi verificare la corretta installazione di Node.js lanciando il comando:

node -v
v12.18.3

Deploy dell’applicazione

A questo punto puoi procedere con il primo deploy dalla tua macchina di sviluppo, lanciando il comando sotto indicato, nella cartella del progetto creato in precedenza:

npx shipit staging deploy

Dopo aver eseguito il comando, il processo di deploy ti chiederà di inserire più volte la password del server remoto per effettuare tutte le operazioni necessarie.

Durante lo stesso, verranno stampate a video una serie di informazioni sullo stato del deploy. Una volta completato dovresti visualizzare un messaggio del genere:

Finished 'deploy:finish' after 178 μs

Connettendoti alla macchina remota, puoi verificare il deploy lanciando il comando:

ls /var/node/shipit-test/current/

index.js  package.json  REVISION  shipitfile.js

Come indicato sopra, dovresti visualizzare tutti i file necessari al corretto funzionamento del progetto.

Ottimizzazione del deploy e primo avvio

Allo stato attuale, hai configurato Shipit per fare il deploy dei sorgenti aggiornati nel server remoto. Tuttavia, per sfruttare al meglio le potenzialità di Shipit, puoi utilizzare il suo sistema di eventi per avviare la tua applicazione a deploy concluso.

Per prima cosa devi installare sul server remoto PM2: un software utilizzato per mantenere attivi processi node come demoni.

Quindi lancia sul server remoto:

npm i -g pm2

Puoi quindi modificare il file shipitfile.js aggiungendo un nuovo task chiamato “pm2-setup” come segue:

  shipit.blTask('pm2-setup', async () => {

    // Eliminiamo eventuali demoni precedenti:
    await shipit.remote(`pm2 delete -s shipittest || :`);

    // Lanciamo l’installazione dei pacchetti npm della attuale directory di deploy
    await shipit.remote(`cd ${shipit.currentPath} && npm i`);

    // Avviamo il demone tramite pm2
    await shipit.remote(
      `pm2 start --name shipittest ${shipit.currentPath}/index.js --env production`
    );

  });

Una volta creato questo nuovo task puoi agganciarlo all’evento “deployed”:

shipit.on('deployed', async () => {
    shipit.start('pm2-setup');
  });

Il file finale dovrebbe quindi risultare come sotto:

module.exports = shipit => {
  // Load shipit-deploy tasks
  require('shipit-deploy')(shipit)

 shipit.initConfig({
    default: {
      deployTo: '/var/node/shipit-test',
      repositoryUrl: 'https://github.com/[NOME_UTENTE_GITHUB]/[NOME_REPO].git',
    },
    staging: {
      servers: 'deploy@[INDIRIZZO_IP_SERVER_REMOTO]',
    },
  })

  shipit.blTask('pm2-setup', async () => {

    // Eliminiamo eventuali demoni precedenti:
    await shipit.remote(`pm2 delete -s shipittest || :`);

    // Lanciamo l’installazione dei pacchetti npm della attuale directory di deploy
    await shipit.remote(`cd ${shipit.currentPath} && npm i`);

    // Avviamo il demone tramite pm2
    await shipit.remote(
      `pm2 start --name shipittest ${shipit.currentPath}/index.js --env production`
    );

  });

  shipit.on('deployed', async () => {
    shipit.start('pm2-setup');
  });
}

Procedi quindi rilanciando il deploy dalla tua macchia di sviluppo:

npx shipit staging deploy

Se tutto funziona correttamente la tua applicazione risponderà all’indirizzo della macchina remota, sulla porta 3000, ad esempio:

http://[INDIRIZZO_IP_MACCHINA_REMOTA]:3000

Conclusione

In questo tutorial hai utilizzato solo alcune delle potenzialità offerte da Shipit, strumento che ti permette di eseguire il deploy e automatizzare diverse task sui tuoi server remoti. Per maggiori informazioni sull’utilizzo di questa suite, puoi consultare le guide ufficiali presenti su GitHub:

https://github.com/shipitjs/shipit

https://github.com/shipitjs/shipit/tree/master/packages/shipit-deploy

Shipit ti permette inoltre di automatizzare molte operazioni tra macchina locale e remota, aggiungere diversi task ed eventi in base alle necessità della tua applicazione.

Per maggiori informazioni sul pacchetto PM2, ti consigliamo inoltre di visionare questa documentazione:

https://pm2.keymetrics.io/docs/usage/pm2-doc-single-page/