Nextcloud è un'applicazione open source di sincronizzazione e condivisione di file che offre archiviazione di file cloud gratuita, sicura e facilmente accessibile, nonché una serie di strumenti che ne estendono il set di funzionalità. È molto simile al popolare Dropbox, iCloud e Google Drive ma, a differenza di Dropbox, Nextcloud non offre l'hosting di archiviazione file fuori sede.
In questo post del blog, implementeremo una configurazione ad alta disponibilità per la nostra infrastruttura privata "Dropbox" utilizzando Nextcloud, GlusterFS, Percona XtraDB Cluster (MySQL Galera Cluster), ProxySQL con ClusterControl come strumento di automazione per gestire e monitorare il database e i livelli di bilanciamento del carico.
Nota:puoi anche utilizzare MariaDB Cluster, che utilizza la stessa libreria di replica sottostante come in Percona XtraDB Cluster. Dal punto di vista del bilanciamento del carico, ProxySQL si comporta in modo simile a MaxScale in quanto può comprendere il traffico SQL e ha un controllo dettagliato su come viene instradato il traffico.
Architettura di database per Nexcloud
In questo post del blog, abbiamo utilizzato un totale di 6 nodi.
- 2 server proxy
- 3 x database + server delle applicazioni
- 1 server di controllo (ClusterControl)
Il diagramma seguente illustra la nostra configurazione finale:
Per Percona XtraDB Cluster, sono necessari almeno 3 nodi per un solido replica multimaster. Le applicazioni Nextcloud sono co-posizionate all'interno dei server di database, quindi GlusterFS deve essere configurato anche su quegli host.
Il livello del sistema di bilanciamento del carico è costituito da 2 nodi per scopi di ridondanza. Utilizzeremo ClusterControl per distribuire il livello di database e i livelli di bilanciamento del carico. Tutti i server sono in esecuzione su CentOS 7 con la seguente definizione /etc/hosts su ogni nodo:
192.168.0.21 nextcloud1 db1
192.168.0.22 nextcloud2 db2
192.168.0.23 nextcloud3 db3
192.168.0.10 vip db
192.168.0.11 proxy1 lb1 proxysql1
192.168.0.12 proxy2 lb2 proxysql2Si noti che GlusterFS e MySQL sono processi altamente intensivi. Se stai seguendo questa configurazione (GlusterFS e MySQL risiedono in un unico server), assicurati di avere specifiche hardware decenti per i server.
Distribuzione del database Nextcloud
Inizieremo con la distribuzione del database per il nostro cluster Percona XtraDB a tre nodi utilizzando ClusterControl. Installare ClusterControl e quindi configurare SSH senza password su tutti i nodi che verranno gestiti da ClusterControl (3 PXC + 2 proxy). Sul nodo ClusterControl, eseguire:
$ whoami
root
$ ssh-copy-id 192.168.0.11
$ ssh-copy-id 192.168.0.12
$ ssh-copy-id 192.168.0.21
$ ssh-copy-id 192.168.0.22
$ ssh-copy-id 192.168.0.23**Inserisci la password di root per il rispettivo host quando richiesto.
Apri un browser web e vai a https://{ClusterControl-IP-address}/clustercontrol e crea un super utente. Quindi vai su Distribuisci -> MySQL Galera. Segui la procedura guidata di distribuzione di conseguenza. Nella seconda fase "Definisci server MySQL", scegli Percona XtraDB 5.7 e specifica l'indirizzo IP per ogni nodo del database. Assicurati di ottenere un segno di spunta verde dopo aver inserito i dettagli del nodo del database, come mostrato di seguito:
Fai clic su "Distribuisci" per avviare la distribuzione. Il cluster di database sarà pronto in 15~20 minuti. È possibile seguire l'avanzamento della distribuzione in Attività -> Lavori -> Crea cluster -> Dettagli completi sul lavoro. Il cluster verrà elencato nella dashboard del cluster di database una volta distribuito.
Ora possiamo procedere alla distribuzione del servizio di bilanciamento del carico del database.
Distribuzione del sistema di bilanciamento del carico del database Nextcloud
Si consiglia di eseguire Nextcloud su una configurazione a scrittore singolo, in cui le scritture verranno elaborate da un master alla volta e le letture possono essere distribuite ad altri nodi. Possiamo utilizzare ProxySQL 2.0 per ottenere questa configurazione poiché può indirizzare le query di scrittura a un singolo master.
Per distribuire un ProxySQL, fare clic su Azioni cluster> Aggiungi Load Balancer> ProxySQL> Distribuisci ProxySQL. Inserisci le informazioni richieste come evidenziato dalle frecce rosse:
Compila tutti i dettagli necessari come evidenziato dalle frecce sopra. L'indirizzo del server è il server lb1, 192.168.0.11. Più in basso, specifichiamo l'amministratore ProxySQL e la password degli utenti di monitoraggio. Quindi includi tutti i server MySQL nel set di bilanciamento del carico e quindi scegli "No" nella sezione Transazioni implicite. Fai clic su "Distribuisci proxySQL" per avviare la distribuzione.
Ripetere gli stessi passaggi di cui sopra per il servizio di bilanciamento del carico secondario, lb2 (ma modificare l'"Indirizzo del server" con l'indirizzo IP di lb2). Altrimenti, non avremmo ridondanza in questo livello.
I nostri nodi ProxySQL sono ora installati e configurati con due gruppi host per Galera Cluster. Uno per il gruppo a master singolo (gruppo host 10), dove tutte le connessioni verranno inoltrate a un nodo Galera (questo è utile per prevenire deadlock multi-master) e il gruppo multi-master (gruppo host 20) per tutti i carichi di lavoro di sola lettura che sarà bilanciato su tutti i server MySQL di back-end.
Successivamente, dobbiamo distribuire un indirizzo IP virtuale per fornire un singolo endpoint per i nostri nodi ProxySQL in modo che la tua applicazione non debba definire due diversi host ProxySQL. Ciò fornirà anche funzionalità di failover automatico perché l'indirizzo IP virtuale verrà rilevato dal nodo ProxySQL di backup nel caso qualcosa vada storto al nodo ProxySQL primario.
Vai a ClusterControl -> Gestisci -> Load Balancer -> Keepalived -> Distribuisci Keepalived. Scegli "ProxySQL" come tipo di bilanciamento del carico e scegli due server ProxySQL distinti dal menu a discesa. Quindi specifica l'indirizzo IP virtuale e l'interfaccia di rete che ascolterà, come mostrato nell'esempio seguente:
Una volta completata la distribuzione, dovresti vedere i seguenti dettagli sulla barra di riepilogo del cluster:
Infine, crea un nuovo database per la nostra applicazione andando su ClusterControl -> Gestisci -> Schemi e Utenti -> Crea database e specificando "nextcloud". ClusterControl creerà questo database su ogni nodo Galera. Il nostro livello di bilanciamento del carico è ora completo.
Distribuzione di GlusterFS per Nextcloud
I seguenti passaggi devono essere eseguiti su nextcloud1, nextcloud2, nextcloud3 se non diversamente specificato.
Fase uno
Si consiglia di avere un this separato per l'archiviazione GlusterFS, quindi aggiungeremo un disco aggiuntivo in /dev/sdb e creeremo una nuova partizione:
$ fdisk /dev/sdbSegui la procedura guidata di creazione della partizione fdisk premendo il tasto seguente:
n > p > Enter > Enter > Enter > wFase due
Verifica se /dev/sdb1 è stato creato:
$ fdisk -l /dev/sdb1
Disk /dev/sdb1: 8588 MB, 8588886016 bytes, 16775168 sectors
Units = sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytesFase tre
Formatta la partizione con XFS:
$ mkfs.xfs /dev/sdb1Fase quattro
Monta la partizione come /storage/brick:
$ mkdir /glusterfs
$ mount /dev/sdb1 /glusterfsVerifica che tutti i nodi abbiano il seguente layout:
$ lsblk
NAME MAJ:MIN RM SIZE RO TYPE MOUNTPOINT
sda 8:0 0 40G 0 disk
└─sda1 8:1 0 40G 0 part /
sdb 8:16 0 8G 0 disk
└─sdb1 8:17 0 8G 0 part /glusterfsFase Cinque
Crea una sottodirectory chiamata brick sotto /glusterfs:
$ mkdir /glusterfs/brickFase sei
Per la ridondanza dell'applicazione, possiamo usare GlusterFS per la replica dei file tra gli host. Innanzitutto, installa il repository GlusterFS per CentOS:
$ yum install centos-release-gluster -y
$ yum install epel-release -yPasso sette
Installa il server GlusterFS
$ yum install glusterfs-server -yPasso otto
Abilita e avvia il demone gluster:
$ systemctl enable glusterd
$ systemctl start glusterdFase nove
Su nextcloud1, sonda gli altri nodi:
(nextcloud1)$ gluster peer probe 192.168.0.22
(nextcloud1)$ gluster peer probe 192.168.0.23Puoi verificare lo stato del peer con il seguente comando:
(nextcloud1)$ gluster peer status
Number of Peers: 2
Hostname: 192.168.0.22
Uuid: f9d2928a-6b64-455a-9e0e-654a1ebbc320
State: Peer in Cluster (Connected)
Hostname: 192.168.0.23
Uuid: 100b7778-459d-4c48-9ea8-bb8fe33d9493
State: Peer in Cluster (Connected)Passo dieci
Su nextcloud1, crea un volume replicato sui nodi sondati:
(nextcloud1)$ gluster volume create rep-volume replica 3 192.168.0.21:/glusterfs/brick 192.168.0.22:/glusterfs/brick 192.168.0.23:/glusterfs/brick
volume create: rep-volume: success: please start the volume to access dataFase undici
Avvia il volume replicato su nextcloud1:
(nextcloud1)$ gluster volume start rep-volume
volume start: rep-volume: successVerifica che il volume e i processi replicati siano online:
$ gluster volume status
Status of volume: rep-volume
Gluster process TCP Port RDMA Port Online Pid
------------------------------------------------------------------------------
Brick 192.168.0.21:/glusterfs/brick 49152 0 Y 32570
Brick 192.168.0.22:/glusterfs/brick 49152 0 Y 27175
Brick 192.168.0.23:/glusterfs/brick 49152 0 Y 25799
Self-heal Daemon on localhost N/A N/A Y 32591
Self-heal Daemon on 192.168.0.22 N/A N/A Y 27196
Self-heal Daemon on 192.168.0.23 N/A N/A Y 25820
Task Status of Volume rep-volume
------------------------------------------------------------------------------
There are no active volume tasksFase dodici
Monta il volume replicato su /var/www/html. Crea la directory:
$ mkdir -p /var/www/htmlFase tredici
13) Aggiungi la seguente riga in /etc/fstab per consentire il montaggio automatico:
/dev/sdb1 /glusterfs xfs defaults,defaults 0 0
localhost:/rep-volume /var/www/html glusterfs defaults,_netdev 0 0Fase quattordici
Monta GlusterFS su /var/www/html:
$ mount -aE verifica con:
$ mount | grep gluster
/dev/sdb1 on /glusterfs type xfs (rw,relatime,seclabel,attr2,inode64,noquota)
localhost:/rep-volume on /var/www/html type fuse.glusterfs (rw,relatime,user_id=0,group_id=0,default_permissions,allow_other,max_read=131072)Il volume replicato è ora pronto e montato in ogni nodo. Ora possiamo procedere alla distribuzione dell'applicazione.
Distribuzione dell'applicazione Nextcloud
I seguenti passaggi devono essere eseguiti su nextcloud1, nextcloud2 e nextcloud3 se non diversamente specificato.
Nextcloud richiede PHP 7.2 e versioni successive e per la distribuzione CentOS, dobbiamo abilitare una serie di repository come EPEL e Remi per semplificare il processo di installazione.
Fase uno
Se SELinux è abilitato, disabilitalo prima:
$ setenforce 0
$ sed -i 's/^SELINUX=.*/SELINUX=permissive/g' /etc/selinux/configPuoi anche eseguire Nextcloud con SELinux abilitato seguendo questa guida.
Fase due
Installa i requisiti Nextcloud e abilita il repository Remi per PHP 7.2:
$ yum install -y epel-release yum-utils unzip curl wget bash-completion policycoreutils-python mlocate bzip2
$ yum install -y http://rpms.remirepo.net/enterprise/remi-release-7.rpm
$ yum-config-manager --enable remi-php72Fase tre
Installa le dipendenze Nextcloud, principalmente pacchetti correlati ad Apache e PHP 7.2:
$ yum install -y httpd php72-php php72-php-gd php72-php-intl php72-php-mbstring php72-php-mysqlnd php72-php-opcache php72-php-pecl-redis php72-php-pecl-apcu php72-php-pecl-imagick php72-php-xml php72-php-pecl-zipFase quattro
Abilita Apache e avvialo:
$ systemctl enable httpd.service
$ systemctl start httpd.serviceFase Cinque
Crea un collegamento simbolico affinché PHP utilizzi il binario PHP 7.2:
$ ln -sf /bin/php72 /bin/phpSesto passo
Su nextcloud1, scarica Nextcloud Server da qui ed estrailo:
$ wget https://download.nextcloud.com/server/releases/nextcloud-17.0.0.zip
$ unzip nextcloud*Passo sette
Su nextcloud1, copia la directory in /var/www/html e assegna la proprietà corretta:
$ cp -Rf nextcloud /var/www/html
$ chown -Rf apache:apache /var/www/html**Nota che il processo di copia in /var/www/html richiederà del tempo a causa della replica del volume GlusterFS.
Passo otto
Prima di procedere con l'apertura della procedura guidata di installazione, dobbiamo disabilitare la variabile pxc_strict_mode su una variabile diversa da "ENFORCING" (il valore predefinito). Ciò è dovuto al fatto che l'importazione del database Nextcloud avrà un numero di tabelle senza chiave primaria definita che non è consigliabile eseguire su Galera Cluster. Questo è spiegato in ulteriori dettagli nella sezione Tuning più in basso.
Per modificare la configurazione con ClusterControl è sufficiente andare su Gestisci -> Configurazioni -> Modifica/Imposta parametri:
Scegli tutte le istanze del database dall'elenco e inserisci:
- Gruppo:MYSQLD
- Parametro:pxc_strict_mode
- Nuovo valore:PERMISSIVO
ClusterControl eseguirà automaticamente le modifiche necessarie su ogni nodo del database. Se il valore può essere modificato durante il runtime, sarà immediatamente effettivo. ClusterControl configura anche il valore all'interno del file di configurazione MySQL per la persistenza. Dovresti vedere il seguente risultato:
Fase nove
Ora siamo pronti per configurare la nostra installazione di Nextcloud. Apri il browser e vai al server HTTP di nextcloud1 all'indirizzo http://192.168.0.21/nextcloud/ e ti verrà presentata la seguente procedura guidata di configurazione:
Configura la sezione "Archiviazione e database" con il seguente valore:
- Cartella dati:/var/www/html/nextcloud/data
- Configura il database:MySQL/MariaDB
- Nome utente:nextcloud
- Password:(la password per l'utente nextcloud)
- Banca dati:nextcloud
- Host:192.168.0.10:6603 (l'indirizzo IP virtuale con la porta ProxySQL)
Fare clic su "Fine configurazione" per avviare il processo di configurazione. Attendi fino al termine e verrai reindirizzato alla dashboard di Nextcloud per l'utente "admin". L'installazione è ora completata. La prossima sezione fornisce alcuni suggerimenti per l'ottimizzazione per funzionare in modo efficiente con Galera Cluster.
Ottimizzazione del database Nextcloud
Chiave primaria
Avere una chiave primaria su ogni tabella è vitale per la replica del set di scrittura di Galera Cluster. Per una tabella relativamente grande senza chiave primaria, una transazione di aggiornamento o eliminazione di grandi dimensioni bloccherebbe completamente il tuo cluster per molto tempo. Per evitare stranezze e casi limite, assicurati semplicemente che tutte le tabelle utilizzino il motore di archiviazione InnoDB con una chiave primaria esplicita (la chiave univoca non conta).
L'installazione predefinita di Nextcloud creerà un gruppo di tabelle nel database specificato e alcune di esse non rispettano questa regola. Per verificare se le tabelle sono compatibili con Galera, possiamo eseguire la seguente istruzione:
mysql> SELECT DISTINCT CONCAT(t.table_schema,'.',t.table_name) as tbl, t.engine, IF(ISNULL(c.constraint_name),'NOPK','') AS nopk, IF(s.index_type = 'FULLTEXT','FULLTEXT','') as ftidx, IF(s.index_type = 'SPATIAL','SPATIAL','') as gisidx FROM information_schema.tables AS t LEFT JOIN information_schema.key_column_usage AS c ON (t.table_schema = c.constraint_schema AND t.table_name = c.table_name AND c.constraint_name = 'PRIMARY') LEFT JOIN information_schema.statistics AS s ON (t.table_schema = s.table_schema AND t.table_name = s.table_name AND s.index_type IN ('FULLTEXT','SPATIAL')) WHERE t.table_schema NOT IN ('information_schema','performance_schema','mysql') AND t.table_type = 'BASE TABLE' AND (t.engine <> 'InnoDB' OR c.constraint_name IS NULL OR s.index_type IN ('FULLTEXT','SPATIAL')) ORDER BY t.table_schema,t.table_name;
+---------------------------------------+--------+------+-------+--------+
| tbl | engine | nopk | ftidx | gisidx |
+---------------------------------------+--------+------+-------+--------+
| nextcloud.oc_collres_accesscache | InnoDB | NOPK | | |
| nextcloud.oc_collres_resources | InnoDB | NOPK | | |
| nextcloud.oc_comments_read_markers | InnoDB | NOPK | | |
| nextcloud.oc_federated_reshares | InnoDB | NOPK | | |
| nextcloud.oc_filecache_extended | InnoDB | NOPK | | |
| nextcloud.oc_notifications_pushtokens | InnoDB | NOPK | | |
| nextcloud.oc_systemtag_object_mapping | InnoDB | NOPK | | |
+---------------------------------------+--------+------+-------+--------+L'output sopra mostra che ci sono 7 tabelle che non hanno una chiave primaria definita. Per risolvere quanto sopra, aggiungi semplicemente una chiave primaria con la colonna di incremento automatico. Esegui i seguenti comandi su uno dei server di database, ad esempio nexcloud1:
(nextcloud1)$ mysql -uroot -p
mysql> ALTER TABLE nextcloud.oc_collres_accesscache ADD COLUMN `id` INT PRIMARY KEY AUTO_INCREMENT;
mysql> ALTER TABLE nextcloud.oc_collres_resources ADD COLUMN `id` INT PRIMARY KEY AUTO_INCREMENT;
mysql> ALTER TABLE nextcloud.oc_comments_read_markers ADD COLUMN `id` INT PRIMARY KEY AUTO_INCREMENT;
mysql> ALTER TABLE nextcloud.oc_federated_reshares ADD COLUMN `id` INT PRIMARY KEY AUTO_INCREMENT;
mysql> ALTER TABLE nextcloud.oc_filecache_extended ADD COLUMN `id` INT PRIMARY KEY AUTO_INCREMENT;
mysql> ALTER TABLE nextcloud.oc_notifications_pushtokens ADD COLUMN `id` INT PRIMARY KEY AUTO_INCREMENT;
mysql> ALTER TABLE nextcloud.oc_systemtag_object_mapping ADD COLUMN `id` INT PRIMARY KEY AUTO_INCREMENT;Una volta applicate le modifiche di cui sopra, possiamo riconfigurare pxc_strict_mode al valore consigliato, "ENFORCING". Ripetere il passaggio n. 8 nella sezione "Distribuzione dell'applicazione" con il valore corrispondente.
Livello di isolamento READ-COMMITTED
Il livello di isolamento della transazione consigliato, come consigliato da Nextcloud, è l'utilizzo di READ-COMMITTED, mentre il cluster Galera è impostato su un livello di isolamento REPEATABLE-READ più severo. L'utilizzo di READ-COMMITTED può evitare la perdita di dati in scenari di carico elevato (ad es. utilizzando il client di sincronizzazione con molti client/utenti e molte operazioni parallele).
Per modificare il livello di transazione, vai su ClusterControl -> Gestisci -> Configurazioni -> Modifica/Imposta parametro e specifica quanto segue:
Fai clic su "Procedi" e ClusterControl applicherà immediatamente le modifiche alla configurazione. Non è richiesto il riavvio del database.
Nextcloud multiistanza
Poiché abbiamo eseguito l'installazione su nextcloud1 durante l'accesso all'URL, questo indirizzo IP viene automaticamente aggiunto nella variabile 'trusted_domains' all'interno di Nextcloud. Quando si tenta di accedere ad altri server, ad esempio il server secondario, http://192.168.0.22/nextcloud, viene visualizzato un errore indicante che questo host non è autorizzato e deve essere aggiunto nella variabile trusted_domain.
Pertanto, aggiungi tutti gli indirizzi IP degli host sotto l'array "trusted_domain" all'interno di /var/www/html/nextcloud/config/config.php, come esempio di seguito:
'trusted_domains' =>
array (
0 => '192.168.0.21',
1 => '192.168.0.22',
2 => '192.168.0.23'
),La configurazione precedente consente agli utenti di accedere a tutti e tre i server delle applicazioni tramite i seguenti URL:
- http://192.168.0.21/nextcloud (nextcloud1)
- http://192.168.0.22/nextcloud (nextcloud2)
- http://192.168.0.23/nextcloud (nextcloud3)
Nota:puoi aggiungere un livello di bilanciamento del carico su queste tre istanze Nextcloud per ottenere un'elevata disponibilità per il livello applicazione utilizzando proxy inversi HTTP disponibili sul mercato come HAProxy o nginx. Questo esula dallo scopo di questo post sul blog.
Utilizzo di Redis per il blocco dei file
Il meccanismo di blocco dei file transazionali di Nextcloud blocca i file per evitare il danneggiamento dei file durante il normale funzionamento. Si consiglia di installare Redis per occuparsi del blocco dei file transazionali (questo è abilitato per impostazione predefinita) che alleggerirà il cluster di database dalla gestione di questo lavoro pesante.
Per installare Redis, è sufficiente:
$ yum install -y redis
$ systemctl enable redis.service
$ systemctl start redis.serviceAggiungi le seguenti righe all'interno di /var/www/html/nextcloud/config/config.php:
'filelocking.enabled' => true,
'memcache.locking' => '\OC\Memcache\Redis',
'redis' => array(
'host' => '192.168.0.21',
'port' => 6379,
'timeout' => 0.0,
),Per maggiori dettagli, consulta questa documentazione, Blocco dei file transazionali.
Conclusione
Nextcloud può essere configurato per essere un servizio di file hosting scalabile e ad alta disponibilità per soddisfare le tue esigenze di condivisione di file privati. In questo blog, abbiamo mostrato come portare la ridondanza nei livelli Nextcloud, file system e database.
