Esecuzione di Nextcloud come container Podman su Rocky Linux¶
Introduzione¶
Questo documento spiega tutti i passi necessari per costruire ed eseguire un'istanza di Nextcloud come container Podman su Rocky Linux. Inoltre, l'intera guida è stata testata su un Raspberry Pi, quindi dovrebbe essere compatibile con ogni architettura di processore supportata da Rocky.
La procedura è suddivisa in più fasi, ognuna con i propri script di shell per l'automazione:
- Installare i pacchetti
podman
ebuildah
per gestire e costruire i nostri container, rispettivamente - Creare un'immagine di base che sarà riutilizzata per tutti i container di cui avremo bisogno
- Creare un'immagine container
db-tools
con gli script di shell necessari per costruire ed eseguire il database MariaDB - Creare ed eseguire MariaDB come container Podman
- Creazione ed esecuzione di Nextcloud come container Podman, utilizzando il container Podman MariaDB come backend
La maggior parte dei comandi della guida può essere eseguita manualmente, ma la creazione di alcuni script bash renderà la vita molto più facile, soprattutto quando si desidera ripetere questi passaggi con impostazioni, variabili o nomi di container diversi.
Nota per i principianti:
Podman è uno strumento per la gestione dei container, in particolare dei container OCI (Open Containers Initiative). È stato progettato per essere praticamente compatibile con Docker, nel senso che la maggior parte, se non tutti, gli stessi comandi funzioneranno per entrambi gli strumenti. Se "Docker" non significa nulla per voi, o anche se siete solo curiosi, potete leggere di più su Podman e su come funziona sul sito web di Podman.
buildah
è uno strumento che costruisce immagini di container Podman basate su "DockerFiles".
Questa guida è stata progettata come esercizio per aiutare le persone a familiarizzare con l'esecuzione dei container Podman in generale e su Rocky Linux in particolare.
Prerequisiti e presupposti¶
Ecco tutto ciò che vi serve, o che dovete sapere, per far funzionare questa guida:
- Familiarità con la riga di comando, gli script bash e la modifica dei file di configurazione di Linux.
- Accesso SSH se si lavora su un computer remoto.
- Un editor di testo a riga di comando di vostra scelta. In questa guida utilizzeremo
vi
. - Una macchina Rocky Linux connessa a Internet (anche in questo caso, un Raspberry Pi può andare bene).
- Molti di questi comandi devono essere eseguiti come root, quindi è necessario avere un utente root o con capacità sudo sulla macchina.
- La familiarità con i server web e MariaDB sarebbe sicuramente utile.
- La familiarità con i container e magari con Docker sarebbe indubbiamente un vantaggio ma non è strettamente essenziale.
Passo 01: Installare podman
e buildah
¶
Innanzitutto, assicuratevi che il vostro sistema sia aggiornato:
dnf update
Successivamente si dovrà installare il repository epel-release
per tutti i pacchetti extra che verranno utilizzati.
dnf -y install epel-release
Una volta fatto questo, è possibile aggiornare di nuovo (cosa che a volte è di aiuto) o semplicemente andare avanti e installare i pacchetti di cui abbiamo bisogno:
dnf -y install podman buildah
Una volta installati, eseguire podman --version
e buildah --version
per verificare che tutto funzioni correttamente.
Per accedere al registro di Red Hat per scaricare le immagini dei container, è necessario eseguire:
vi /etc/containers/registries.conf
Trovate la sezione che assomiglia a quella che vedete qui sotto. Se è commentato, decommentarlo.
[registries.insecure]
registries = ['registry.access.redhat.com', 'registry.redhat.io', 'docker.io']
insecure = true
Passo 02: Creare l'immagine di base
del container¶
In questa guida lavoreremo come utente root, ma è possibile eseguire questa operazione in qualsiasi directory home. Passare alla directory principale, se non lo si è già fatto:
cd /root
Ora create tutte le directory necessarie per le varie build del container:
mkdir base db-tools mariadb nextcloud
Ora cambiate la vostra directory di lavoro nella cartella dell'immagine di base:
cd /root/base
E creare un file chiamato DockerFile. Sì, anche Podman li usa.
vi Dockerfile
Copiare e incollare il seguente testo nel nuovo file Docker.
FROM rockylinux/rockylinux:latest
ENV container docker
RUN yum -y install epel-release ; yum -y update
RUN dnf module enable -y php:7.4
RUN dnf install -y php
RUN yum install -y bzip2 unzip lsof wget traceroute nmap tcpdump bridge-utils ; yum -y update
RUN (cd /lib/systemd/system/sysinit.target.wants/; for i in *; do [ $i == \
systemd-tmpfiles-setup.service ] || rm -f $i; done); \
rm -f /lib/systemd/system/multi-user.target.wants/*;\
rm -f /etc/systemd/system/*.wants/*;\
rm -f /lib/systemd/system/local-fs.target.wants/*; \
rm -f /lib/systemd/system/sockets.target.wants/*udev*; \
rm -f /lib/systemd/system/sockets.target.wants/*initctl*; \
rm -f /lib/systemd/system/basic.target.wants/*;\
rm -f /lib/systemd/system/anaconda.target.wants/*;
VOLUME [ "/sys/fs/cgroup" ]
CMD ["/usr/sbin/init"]
Salvare e chiudere il file precedente e creare un nuovo file di script bash:
vi build.sh
Quindi incollare questo contenuto:
#!/bin/bash
clear
buildah rmi `buildah images -q base` ;
buildah bud --no-cache -t base . ;
buildah images -a
Ora rendete eseguibile lo script di compilazione con:
chmod +x build.sh
E poi eseguire:
./build.sh
Attendere che sia terminato e passare alla fase successiva.
Passo 03: Creare l'immagine db-tools
del container¶
Per gli scopi di questa guida, manteniamo la configurazione del database il più semplice possibile. Si consiglia di tenere traccia dei seguenti elementi e di modificarli se necessario:
- Nome del database: ncdb
- Utente del database: nc-user
- Pass per il database: nc-pass
- L'indirizzo IP del vostro server (di seguito utilizzeremo un IP di esempio)
Per prima cosa, spostarsi nella cartella in cui si costruirà l'immagine di db-tools:
cd /root/db-tools
Ora impostiamo alcuni script bash che saranno usati all'interno dell'immagine del container Podman. Per prima cosa, create lo script che costruirà automaticamente il database per voi:
vi db-create.sh
Ora copiate e incollate il seguente codice nel file, utilizzando il vostro editor di testo preferito:
#!/bin/bash
mysql -h 10.1.1.160 -u root -p rockylinux << eof
create database ncdb;
grant all on ncdb.* to 'nc-user'@'10.1.1.160' identified by 'nc-pass';
flush privileges;
eof
Salvare e chiudere, quindi ripetere i passaggi con lo script per l'eliminazione dei database, se necessario:
vi db-drop.sh
Copiate e incollate questo codice nel nuovo file:
#!/bin/bash
mysql -h 10.1.1.160 -u root -p rockylinux << eof
drop database ncdb;
flush privileges;
eof
Infine, impostare il file Docker per l'immagine db-tools
:
vi Dockerfile
Copia e incolla:
FROM localhost/base
RUN yum -y install mysql
WORKDIR /root
COPY db-drop.sh db-drop.sh
COPY db-create.sh db-create.sh
Infine, ma non meno importante, creare lo script bash per costruire l'immagine a comando:
vi build.sh
Il codice che si desidera ottenere:
#!/bin/bash
clear
buildah rmi `buildah images -q db-tools` ;
buildah bud --no-cache -t db-tools . ;
buildah images -a
Salvare e chiudere, quindi rendere il file eseguibile:
chmod +x build.sh
E poi eseguire:
./build.sh
Passo 04: Creare l'immagine del container MariaDB¶
State prendendo confidenza con il processo, vero? È il momento di costruire il container del database vero e proprio. Cambiare la directory di lavoro in /root/mariadb
:
cd /root/mariadb
Creare uno script per (ri)costruire il container ogni volta che si vuole:
vi db-init.sh
Ed ecco il codice necessario:
Attenzione
Ai fini di questa guida, il seguente script cancellerà tutti i Volumi Podman. Se ci sono altre applicazioni in esecuzione con i propri volumi, modificare/commentare la riga "podman volume rm --all";
#!/bin/bash
clear
echo " "
echo "Deleting existing volumes if any...."
podman volume rm --all ;
echo " "
echo "Starting mariadb container....."
podman run --name mariadb --label mariadb -d --net host -e MYSQL_ROOT_PASSWORD=rockylinux -v /sys/fs/cgroup:/sys/fs/cgroup:ro -v mariadb-data:/var/lib/mysql/data:Z mariadb ;
echo " "
echo "Initializing mariadb (takes 2 minutes)....."
sleep 120 ;
echo " "
echo "Creating ncdb Database for nextcloud ....."
podman run --rm --net host db-tools /root/db-create.sh ;
echo " "
echo "Listing podman volumes...."
podman volume ls
È qui che si crea uno script per resettare il database ogni volta che lo si desidera:
vi db-reset.sh
Ed ecco il codice:
#!/bin/bash
clear
echo " "
echo "Deleting ncdb Database for nextcloud ....."
podman run --rm --net host db-tools /root/db-drop.sh ;
echo " "
echo "Creating ncdb Database for nextcloud ....."
podman run --rm --net host db-tools /root/db-create.sh ;
Infine, ecco lo script di compilazione che metterà insieme l'intero container mariadb:
vi build.sh
With its code:
#!/bin/bash
clear
buildah rmi `buildah images -q mariadb` ;
buildah bud --no-cache -t mariadb . ;
buildah images -a
Ora create il vostro DockferFile (vi Dockerfile
) e incollate la seguente singola riga:
FROM arm64v8/mariadb
Ora rendete eseguibile il vostro script di compilazione ed eseguitelo:
chmod +x *.sh
./build.sh
Passo 05: Creare ed eseguire il container Nextcloud¶
Siamo alla fase finale e il processo si ripete praticamente da solo. Passare alla directory dell'immagine di Nextcloud:
cd /root/nextcloud
Questa volta impostate il vostro file Docker per primo, per una questione di varietà:
vi Dockerfile
Nota
Il prossimo punto presuppone l'architettura ARM (per il Raspberry Pi), quindi se si utilizza un'altra architettura, ricordarsi di cambiarla.
E incollare questo pezzo:
FROM arm64v8/nextcloud
Ora create il vostro script di compilazione:
vi build.sh
E incollare questo codice:
#!/bin/bash
clear
buildah rmi `buildah images -q nextcloud` ;
buildah bud --no-cache -t nextcloud . ;
buildah images -a
Ora, si imposterà un gruppo di cartelle locali sul server host (non in un container Podman), in modo da poter ricostruire i nostri container e database senza temere di perdere tutti i nostri file:
mkdir -p /usr/local/nc/nextcloud /usr/local/nc/apps /usr/local/nc/config /usr/local/nc/data
Infine, creeremo lo script che costruirà effettivamente il container Nextcloud per noi:
vi run.sh
Ecco tutto il codice necessario per farlo. Assicurarsi di cambiare l'indirizzo IP di MYSQL_HOST
con il container docker su cui è in esecuzione l'istanza di MariaDB.
#!/bin/bash
clear
echo " "
echo "Starting nextloud container....."
podman run --name nextcloud --net host --privileged -d -p 80:80 \
-e MYSQL_HOST=10.1.1.160 \
-e MYSQL_DATABASE=ncdb \
-e MYSQL_USER=nc-user \
-e MYSQL_PASSWORD=nc-pass \
-e NEXTCLOUD_ADMIN_USER=admin \
-e NEXTCLOUD_ADMIN_PASSWORD=rockylinux \
-e NEXTCLOUD_DATA_DIR=/var/www/html/data \
-e NEXTCLOUD_TRUSTED_DOMAINS=10.1.1.160 \
-v /sys/fs/cgroup:/sys/fs/cgroup:ro \
-v /usr/local/nc/nextcloud:/var/www/html \
-v /usr/local/nc/apps:/var/www/html/custom_apps \
-v /usr/local/nc/config:/var/www/html/config \
-v /usr/local/nc/data:/var/www/html/data \
nextcloud ;
Salvare e chiudere il file, rendere eseguibili tutti gli script, quindi eseguire prima lo script di creazione dell'immagine:
chmod +x *.sh
./build.sh
Per assicurarsi che tutte le immagini siano state costruite correttamente, eseguire podman images
. Dovrebbe apparire un elenco simile a questo:
REPOSITORY TAG IMAGE ID CREATED SIZE
localhost/db-tools latest 8f7ccb04ecab 6 days ago 557 MB
localhost/base latest 03ae68ad2271 6 days ago 465 MB
docker.io/arm64v8/mariadb latest 89a126188478 11 days ago 405 MB
docker.io/arm64v8/nextcloud latest 579a44c1dc98 3 weeks ago 945 MB
Se tutto sembra corretto, eseguite lo script finale per avviare Nextcloud:
./run.sh
Quando si esegue podman ps -a
, si dovrebbe vedere un elenco di container in esecuzione che assomiglia a questo:
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
9518756a259a docker.io/arm64v8/mariadb:latest mariadbd 3 minutes ago Up 3 minutes ago mariadb
32534e5a5890 docker.io/arm64v8/nextcloud:latest apache2-foregroun... 12 seconds ago Up 12 seconds ago nextcloud
Da qui, si dovrebbe essere in grado di puntare il browser all'indirizzo IP del server. Se state seguendo e avete lo stesso IP del nostro esempio, potete sostituirlo qui (ad esempio, http://your-server-ip) e vedere Nextcloud in funzione.
Conclusione¶
Ovviamente, questa guida dovrà essere modificata in qualche modo su un server di produzione, soprattutto se l'istanza Nextcloud è destinata a essere pubblica. Comunque, questo dovrebbe darvi un'idea di base di come funziona Podman e di come potete configurarlo con script e immagini di base multiple per facilitare le ricostruzioni.
Author: Ananda Kammampati
Contributors: Ezequiel Bruni, Steven Spencer, Ganna Zhyrnova