Capire i trigger<\/h2>\n
Prima di creare operazioni di manutenzione per il proprio database, \u00e8 importante capire i vari modi in cui possono essere attivate. Ogni trigger serve a scopi diversi per facilitare le attivit\u00e0 di manutenzione. I tre trigger principali comunemente utilizzati sono:<\/p>\n
- \n
- Manuale, basato su API<\/strong>: questo trigger permette di eseguire operazioni una tantum utilizzando una chiamata API. \u00c8 utile in situazioni come il ripristino del backup di un database o la ricostruzione degli indici quando le prestazioni calano improvvisamente.<\/li>\n
- Pianificato (come CRON)<\/strong>: questo trigger permette di automatizzare le attivit\u00e0 di manutenzione programmata durante i periodi di scarso traffico di utenti. \u00c8 ideale per eseguire operazioni ad alta intensit\u00e0 di risorse come l’archiviazione e la pulizia. Si possono utilizzare pacchetti come node-schedule<\/a> per impostare pianificazioni in Node.js che attivano automaticamente le operazioni quando necessario.<\/li>\n
- Notifiche del database<\/strong>: questo trigger permette di eseguire operazioni di manutenzione in risposta alle modifiche del database. Ad esempio, quando un utente pubblica un commento su una piattaforma, i dati salvati possono attivare istantaneamente i controlli per caratteri irregolari, linguaggio offensivo o le emoji. L’implementazione di questa funzionalit\u00e0 in Node.js \u00e8 possibile utilizzando pacchetti come pg-listen<\/a>.<\/li>\n<\/ul>\n
Prerequisiti<\/h2>\n
Per seguire questa guida, \u00e8 necessario disporre dei seguenti strumenti sul proprio computer locale:<\/p>\n
- \n
- Git<\/a>: per gestire il controllo di versione del codice sorgente dell’applicazione<\/li>\n
- Node.js<\/a>: per costruire l’applicazione backend<\/li>\n
- psql<\/a>: per interagire con il database PostgreSQL remoto utilizzando il terminale<\/li>\n
- PGAdmin<\/a> (opzionale): per interagire con il database PostgreSQL remoto utilizzando un’interfaccia grafica (GUI).<\/li>\n<\/ul>\n
Creare e ospitare un’applicazione Node.js<\/h3>\n
Creiamo un progetto Node.js, effettuiamo il commit su GitHub e impostiamo una pipeline di auto-deploy su Kinsta. Dovremo anche creare un database PostgreSQL su Kinsta<\/a> per testare le routine di manutenzione.<\/p>\n
Iniziamo creando una nuova directory sul nostro sistema locale con il seguente comando:<\/p>\n
mkdir node-db-maintenance<\/code><\/pre>\nQuindi, entriamo nella cartella appena creata ed eseguiamo il comando qui sotto per creare un nuovo progetto:<\/p>\n
cd node-db-maintenance\nyarn init -y # or npm init -y<\/code><\/pre>\nQuesto inizializza un progetto Node.js con la configurazione predefinita. Ora possiamo installare le dipendenze necessarie eseguendo il comando:<\/p>\n
yarn add express pg nodemon dotenv<\/code><\/pre>\nEcco una rapida descrizione di ogni pacchetto:<\/p>\n
- \n
express<\/code>: permette di creare un’API REST basata su Express.<\/li>\npg<\/code>: permette di interagire con un database PostgreSQL attraverso l’applicazione Node.js.<\/li>\nnodemon<\/code>: consente alla build dev di essere aggiornata durante lo sviluppo dell’applicazione, liberando dalla necessit\u00e0 costante di fermare e avviare l’applicazione ogni volta che si apporta una modifica.<\/li>\ndotenv<\/code>: permette di caricare le variabili d’ambiente da un file .env<\/strong> nell’oggettoprocess.env<\/code>.<\/li>\n<\/ul>\nQuindi, aggiungiamo i seguenti script nel file package.json<\/strong> in modo da poter avviare facilmente il server dev ed eseguirlo anche in produzione:<\/p>\n
{\n \/\/ ... \n \"scripts\": {\n \"start-dev\": \"nodemon index.js\",\n \"start\": \"NODE_ENV=production node index.js\"\n },\n \/\/ \u2026\n}<\/code><\/pre>\nOra possiamo creare un file index.js<\/strong> che contiene il codice sorgente dell’applicazione. Incolliamo il seguente codice nel file:<\/p>\n
const express = require(\"express\")\nconst dotenv = require('dotenv');\n\nif (process.env.NODE_ENV !== 'production') dotenv.config();\nconst app = express()\nconst port = process.env.PORT || 3000\n\napp.get(\"\/health\", (req, res) => res.json({status: \"UP\"}))\n\napp.listen(port, () => {\n console.log(`Server running at port: ${port}`);\n});<\/code><\/pre>\nQuesto codice inizializza un server Express<\/a> e configura le variabili d’ambiente utilizzando il pacchetto
dotenv<\/code> se non \u00e8 in modalit\u00e0 di produzione. Inoltre, imposta una route\/health<\/code> che restituisce un oggetto JSON{status: \"UP\"}<\/code>. Infine, avvia l’applicazione utilizzando la funzioneapp.listen()<\/code> per ascoltare sulla porta specificata, con l’impostazione predefinita di3000<\/code> se non viene fornita alcuna porta tramite la variabile d’ambiente.<\/p>\nOra che abbiamo un’applicazione di base pronta, inizializziamo un nuovo repository git con il nostro provider git preferito (BitBucket<\/a>, GitHub<\/a> o GitLab<\/a>) e inviamo il codice. Kinsta supporta il deploy delle applicazioni da tutti questi provider git. Per questo articolo, usiamo GitHub.<\/p>\n
Quando il repository \u00e8 pronto, seguiamo questi passaggi per distribuire l’applicazione su Kinsta:<\/p>\n
- \n
- Accediamo o creiamo un account per visualizzare la dashboard MyKinsta<\/a>.<\/li>\n
- Autorizziamo Kinsta con il provider Git.<\/li>\n
- Nella barra laterale di sinistra, clicchiamo su Applicazioni<\/strong> e poi su Aggiungi applicazione<\/strong>.<\/li>\n
- Selezioniamo il repository e il branch da cui desideriamo effettuare il deploy.<\/li>\n
- Selezioniamo uno dei data center disponibili dalla lista delle 27 opzioni. Kinsta rileva automaticamente le impostazioni di build delle applicazioni tramite Nixpacks<\/a>.<\/li>\n
- Scegliamo le risorse dell’applicazione, come la RAM e lo spazio su disco.<\/li>\n
- Clicchiamo su Crea applicazione<\/strong>.<\/li>\n<\/ol>\n
Una volta completata la distribuzione, copiamo il link dell’applicazione distribuita e navighiamo su
\/health<\/code>. Dovremmo vedere il seguente JSON nel browser:<\/p>\n{status: \"UP\"}<\/code><\/pre>\nQuesto indica che l’applicazione \u00e8 stata configurata correttamente.<\/p>\n
Impostazione di un’istanza PostgreSQL su Kinsta<\/h3>\n
Kinsta offre un’interfaccia semplice per fornire istanze di database. Iniziamo creando un nuovo account Kinsta<\/a> se non ne abbiamo gi\u00e0 uno. Poi, seguiamo questi passaggi:<\/p>\n
- \n
- Accediamo alla dashboard MyKinsta.<\/li>\n
- Nella barra laterale di sinistra, clicchiamo su Database<\/strong> e poi su Aggiungi database<\/strong>.<\/li>\n
- Selezioniamo PostgreSQL<\/strong> come tipo di database e scegliamo la versione che preferiamo. Scegliamo un nome per il database e modifichiamo il nome utente e la password se lo desideriamo.<\/li>\n
- Selezioniamo un data center dalla lista di 27 opzioni.<\/li>\n
- Scegliamo le dimensioni del database.<\/li>\n
- Clicchiamo su Crea database<\/strong>.<\/li>\n<\/ol>\n
Una volta creato il database, assicuriamoci di recuperare l’host, la porta, il nome utente e la password del database.<\/p>\n
![\"La](\"https:\/\/kinsta.com\/wp-content\/uploads\/2023\/11\/database-credentials-from-kinsta-1024x435.jpg\")
Credenziali del database generate da Kinsta<\/figcaption><\/figure>\n Potremo quindi inserire questi valori nella CLI psql (o nella GUI PGAdmin) per gestire il database. Per testare il codice a livello locale, creiamo un file .env<\/strong> nella directory principale del progetto e inseriamo i seguenti segreti:<\/p>\n
DB_USER_NAME=your database user name\nDB_HOST=your database host\nDB_DATABASE_NAME=your database\u2019s name\nDB_PORT=your database port\nPGPASS=your database password<\/code><\/pre>\nQuando effettuiamo il deploy su Kinsta, dobbiamo aggiungere questi valori come variabili d’ambiente<\/a> al deploy dell’applicazione.<\/p>\n
Per prepararci alle operazioni sul database, scarichiamo ed eseguiamo questo script SQL<\/a> per creare tabelle (utenti, post, commenti) e inserire dati di esempio. Usiamo il comando qui sotto, sostituendo i placeholder con le nostre specifiche, per aggiungere i dati al database PostgreSQL appena creato:<\/p>\n
psql -h <host> -p <port> -U <username> -d <db_name> -a -f <sql file e.g. test-data.sql><\/code><\/pre>\nAssicuriamoci di inserire il nome e il percorso esatto del file nel comando qui sopra. L’esecuzione di questo comando richiede l’inserimento della password del database per l’autorizzazione.<\/p>\n
Una volta completata l’esecuzione di questo comando, saremo pronti a iniziare a scrivere le operazioni di manutenzione del database. Non esitate a inviare il codice al vostro repository Git al termine di ogni operazione per vederlo in azione sulla piattaforma Kinsta.<\/p>\n
Scrivere le routine di manutenzione<\/h2>\n
Questa sezione analizza diverse operazioni comunemente utilizzate per la manutenzione dei database PostgreSQL.<\/p>\n
1. Creare backup<\/h3>\n
Eseguire regolarmente il backup dei database \u00e8 un’operazione comune ed essenziale. Si tratta di creare una copia dell’intero contenuto del database, che viene conservata in un luogo sicuro. Questi backup sono fondamentali per ripristinare i dati in caso di perdita accidentale o di errori che ne compromettono l’integrit\u00e0.<\/p>\n
Anche se piattaforme come Kinsta offrono backup automatici<\/a> come parte dei loro servizi, \u00e8 importante sapere come impostare una routine di backup personalizzata, se necessario.<\/p>\n
PostgreSQL offre lo strumento pg_dump<\/a> per creare backup dei database. Tuttavia, deve essere eseguito direttamente dalla riga di comando e non esiste un pacchetto npm per questo strumento. Quindi, \u00e8 necessario utilizzare il pacchetto @getvim\/execute<\/a> per eseguire il comando
pg_dump<\/code> nell’ambiente locale dell’applicazione Node.<\/p>\nInstalliamo il pacchetto eseguendo il comando:<\/p>\n
yarn add @getvim\/execute<\/code><\/pre>\nSuccessivamente, importiamo il pacchetto nel file index.js<\/strong> aggiungendo questa riga di codice all’inizio:<\/p>\n
const {execute} = require('@getvim\/execute');<\/code><\/pre>\nI backup vengono generati come file sul filesystem locale dell’applicazione Node. Per questo motivo, \u00e8 meglio creare una cartella dedicata con il nome backup<\/strong> nella directory principale del progetto.<\/p>\n
Ora possiamo utilizzare il seguente percorso per generare e scaricare i backup del database quando necessario:<\/p>\n
app.get('\/backup', async (req, res) => {\n\n \/\/ Create a name for the backup file\n const fileName = \"database-backup-\" + new Date().valueOf() + \".tar\";\n\n \/\/ Execute the pg_dump command to generate the backup file\n execute(\"PGPASSWORD=\" + process.env.PGPASS + \" pg_dump -U \" + process.env.DB_USER_NAME \n + \" -d \" + process.env.DB_DATABASE_NAME \n + \" -h \" + process.env.DB_HOST\n + \" -p \" + process.env.DB_PORT\n + \" -f backup\/\" + fileName + \" -F t\"\n\n).then(async () => {\n console.log(\"Backup created\");\n res.redirect(\"\/backup\/\" + fileName)\n }).catch(err => {\n console.log(err);\n res.json({message: \"Something went wrong\"})\n })\n\n})<\/code><\/pre>\nInoltre, dovremo aggiungere la seguente riga all’inizio del file index.js<\/strong> dopo l’inizializzazione dell’applicazione Express:<\/p>\n
app.use('\/backup', express.static('backup'))<\/code><\/pre>\nQuesto permette alla cartella backup<\/strong> di essere servita staticamente utilizzando la funzione middleware
express.static<\/code>, consentendo all’utente di scaricare i file di backup generati dall’applicazione Node.<\/p>\n - Selezioniamo PostgreSQL<\/strong> come tipo di database e scegliamo la versione che preferiamo. Scegliamo un nome per il database e modifichiamo il nome utente e la password se lo desideriamo.<\/li>\n
- Node.js<\/a>: per costruire l’applicazione backend<\/li>\n
- Pianificato (come CRON)<\/strong>: questo trigger permette di automatizzare le attivit\u00e0 di manutenzione programmata durante i periodi di scarso traffico di utenti. \u00c8 ideale per eseguire operazioni ad alta intensit\u00e0 di risorse come l’archiviazione e la pulizia. Si possono utilizzare pacchetti come node-schedule<\/a> per impostare pianificazioni in Node.js che attivano automaticamente le operazioni quando necessario.<\/li>\n