Multipli siti web in diversi container su un server Proxmox 9 con un solo IP Pubblico

tratto da: https://community.ovhcloud.com/community/en/new-os-available-proxmox-virtual-environment-ve-9?id=community_question&sys_id=362f0572b1e7ae14f07803b560bfcdaf

Prerequisiti

  • OVH/Kimsufi dedicated server
  • Proxmox 9 installed by OVH
  • SSH access to the server
  • Basic understanding of Linux networking

Parte 1: Installazione iniziale

1.1 Setup utente amministratore

# SSH into server as root
ssh root@YOUR_SERVER_IP

# Create admin user
adduser utente
usermod -aG sudo utente

# Set up SSH key access
mkdir -p /home/utente/.ssh
cp /root/.ssh/authorized_keys /home/utente/.ssh/
chown -R utente: /home/utente/.ssh
chmod 700 /home/utente/.ssh
chmod 600 /home/utente/.ssh/authorized_keys

# Configure passwordless sudo
echo "utente ALL=(ALL) NOPASSWD:ALL" > /etc/sudoers.d/utente
chmod 440 /etc/sudoers.d/utente

1.2 Accesso Interfaccia Web

Imposto la password di root per poter accedere all’interfaccia web

passwd root

Posso ora accedere alla pagina web di Proxmox: https://YOUR_SERVER_IP:8006

Parte 2: Configurazione di rete dei container

2.1 il problema

La configurazione di default della rete dei container su OVH fallisce a causa di:

  • I container si connettono direttamente alla rete esterna vmbr0
  • Non è prevista la configurazione NAT per i container
  • Mancano le regole di FORWARD tra le reti esterne ed interne

2.2 Creo una rete Bridge interna

Modifica /etc/network/interfaces e aggiungi:

auto vmbr6
iface vmbr6 inet static
address 10.0.0.254/24
bridge-ports none
bridge-stp off
bridge-fd 0
post-up echo 1 > /proc/sys/net/ipv4/ip_forward
post-up iptables -t nat -A POSTROUTING -s 10.0.0.0/24 -o vmbr0 -j MASQUERADE
post-down iptables -t nat -D POSTROUTING -s 10.0.0.0/24 -o vmbr0 -j MASQUERADE

2.3 Attivo il bridge interno

# Bring up the new bridge
ifup vmbr6

# Verify bridge creation
ip addr show vmbr6

2.4 Configuro l’inoltro dei pacchetti:

# Enable IP forwarding permanently
echo 'net.ipv4.ip_forward = 1' >> /etc/sysctl.conf
sysctl -p

# Add FORWARD rules for container-to-internet traffic
iptables -I FORWARD -i vmbr6 -o vmbr0 -j ACCEPT
iptables -I FORWARD -i vmbr0 -o vmbr6 -m state --state RELATED,ESTABLISHED -j ACCEPT

# Importo il forward dei pacchetti web
iptables -t nat -A PREROUTING -i vmbr0 -p tcp --dport 80 -j DNAT --to-destination 10.0.0.100:15080
iptables -t nat -A PREROUTING -i vmbr0 -p tcp --dport 443 -j DNAT --to-destination 10.0.0.100:15443
iptables -A FORWARD -p tcp -d 10.0.0.100 --dport 15080 -j ACCEPT
iptables -A FORWARD -p tcp -d 10.0.0.100 --dport 15443 -j ACCEPT

# Save iptables rules
mkdir -p /etc/iptables
iptables-save > /etc/iptables/rules.v4

Parte 3: Creazione del container di routing

3.1 Download del Template per il Container

Dall’interfaccia web di Proxmox:

  • Vai sul nodo –> local storage
  • Clicca sul tab: “CT Templates”
  • Clicca sul tasto “Templates”
  • Scarica Debian-13-standard

3.2 Crea il container dall’interfaccia web

Dal nodo proxmox premo il tasto destro e scelgo “Crea CT”

  • General tab:
    • CT ID: 100
    • Hostname: your-container-name
    • Set password
    • Add SSH public key (opzionale)
  • Template tab:
    • Select debian-13-standard
  • Root Disk tab:
    • Size: 8GB (adjust as needed)
  • CPU/Memory tabs:
    • Set as needed (1 core, 1GB RAM for basic web server)
  • Network tab:
    • CRITICAL: Change bridge from vmbr0 to vmbr6
    • Set static IP: 10.0.0.100/24 (increment for additional containers)
    • Gateway: 10.0.0.254
  • DNS tab:
    • Use host settings

3.3 Verifica e configurazione Container di routing

# Start container
pct start 100

# Enter container
pct enter 100

# Test connectivity
ping -c 3 10.0.0.254 # Gateway
ping -c 3 8.8.8.8 # Internet

# Applico gli aggiornamenti come di prassi
apt update && apt upgrade -y

# Scarico i pacchetti nginx e Let's Encrypt
apt install python3-acme python3-certbot python3-mock python3-openssl python3-pkg-resources python3-pyparsing python3-zope.interface python3-certbot-nginx nginx

# Rimuovo la configurazione per il sito di default
rm /etc/nginx/sites-enabled/default

# Creo una configurazione di routing per un primo sito web: example.com sul server locale 10.0.0.101
echo 'server {
listen 15080;
listen [::]:15080; # Also listen on IPv6
server_name example.com;

location / {
proxy_pass http://10.0.0.101:80; # Indirizzo del server di destinazione
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
}
}' > /etc/nginx/conf.d/router.conf

# Riavvio il server NGINX
service nginx restart

3.4 Test raggiungibilità sito web

I record DNS del vostro sito “example.com” deve essere configurato con un record di tipo A che punta all’indirizzo IP del vostro server Proxmox

Puntate il vostro browser verso l’indirizzo http://example.com

Se tutto e’ andato a buon fine dovreste vedere la pagina di Welcome di NGINX

3.5 Richiesta del certificato Let’s Encrypt

certbot --nginx -d example.com -m mymail@mydomain.com --agree-tos --no-eff-email --http-01-port 15080

Certbot vi chiederà se redirigere il traffico http a https. Per ora rispondete no.

3.6 Modificate la porta per https:

sed -i 's/listen 443 ssl/listen 15443 ssl/g' /etc/nginx/conf.d/router.conf

# Riavvio NGINX
service nginx restart

Parte 4: Server Web

Potete ora creare un nuovo container per ospitare il sito example.com (potete ripetere questi passaggi per altri nuovi container):

  • General tab:
    • CT ID: 101
    • Hostname: example.com
    • Set password
    • Add SSH public key (opzionale)
  • Template tab:
    • Select debian-13-standard
  • Root Disk tab:
    • Size: 8GB (adjust as needed)
  • CPU/Memory tabs:
    • Set as needed (1 core, 1GB RAM for basic web server)
  • Network tab:
    • CRITICAL: Change bridge from vmbr0 to vmbr6
    • Set static IP: 10.0.0.101/24 (increment for additional containers)
    • Gateway: 10.0.0.254
  • DNS tab:
    • Use host settings

Nota che l’indirizzo IP 10.0.0.101 è quello indicato nel file router.conf visto sopra.

Dalla shell di proxmox:

# Start container
pct start 101

# Enter container
pct enter 101

# Test connectivity
ping -c 3 10.0.0.254 # Gateway
ping -c 3 8.8.8.8 # Internet

# Applico gli aggiornamenti come di prassi
apt update && apt upgrade -y

# Scarico, installo e configuro Caddy
wget -O /tmp/caddy.tar.gz 'https://github.com/caddyserver/caddy/releases/download/v2.7.6/caddy_2.7.6_linux_amd64.tar.gz'
tar -xzf /tmp/caddy.tar.gz -C /usr/local/bin/ caddy
chmod +x /usr/local/bin/caddy

# Verify installation
/usr/local/bin/caddy version

# Create directory structure
mkdir -p /etc/caddy /var/www/html

# Create test page
echo '<h1>Working Caddy Web Server</h1><p>Container networking successful!</p>' > /var/www/html/index.html

# Create basic Caddyfile
echo ':80 {
root * /var/www/html
file_server
}' > /etc/caddy/Caddyfile

# Start Caddy
nohup /usr/local/bin/caddy run --config /etc/caddy/Caddyfile > /var/log/caddy.log 2>&1 &

Potete ora navigare su https://example.com

Avete finito !!

Nel file /etc/nginx/conf.d/router.conf potete aggiungere la configurazione anche per altri siti o server locali modificando il nome del sito o l’indirizzo del server (10.0.0.102, 10.0.0.103 …)

Creazione di un tema personalizzato per Plone 4

Nell’articolo precedente abbiamo visto come installare Plone in un server Ubuntu 10.04, ora vediamo come creare un tema personalizzato per Plone 4.

Dalla cartella principale dove abbiamo installato Plone 4, entrimo nella cartella src:

cd plone402/src

Utilizziamo paster per generare il template:

paster create -t plone3_theme

Alle richieste rispondiamo in questo modo:

Enter project name: plonetheme.testplone4
Variables:
 egg:      plonetheme.testplone4
 package:  plonethemetestplone4
 project:  plonetheme.testplone4
Expert Mode? (What question mode would you like? (easy/expert/all)?) ['easy']:
Skin Name (Name of the theme (human facing, added to portal_skins)) ['']: Tema Test Plone4
Empty Styles? (Override default public stylesheets with empty ones?) [False]:
Include Documentation? (Include in-line documentation in generated code?) [True]:
Version (Version number for project) ['1.0']:
Description (One-line description of the project) ['An installable theme for Plone 3']:

Note:

  • Il nome così formato corrisponde al namespace tipico dei prodotti Plone
  • Lo Skin Name e’ il nome che poi sarà visibile
  • Empty styles: impostando su yes verranno generati automaticamente dei fogli di stile vuoti che avranno la precedenza su quelli standard di Plone. Risulta piu’ semplice però lasciar attivi i CSS originali e andar a sovrascrivere solo le parti da modificare

Il tema è stato ora generato ma dovremo farlo riconoscere a Plone4

cd ..

editiamo il file buildout.cfg e lo modifichiamo in questo modo:

Originale Modificato
develop =
develop =
 src/plonetheme.testplone4
eggs =
 Zope2
 Plone
 ${buildout:eggs}
eggs =
 Zope2
 Plone
 ${buildout:eggs}
 plonetheme.testplone4
zcml =
zcml =
 plonetheme.testplone4

Salviamo le modifiche e rilanciamo lo script buildout

./bin/buildout -v

Il parametro -v aumenta la verbosità

Riavviamo il server:

./bin/instance fg

(per stoppare il server utilizzeremo la combinazione di tasti ctrl+c)

Col browser puntiamo al pannello di configurazione di Plone4: http://192.168.1.203:8080/Plone/plone_control_panel

e selezioniamo il link Prodotti Aggiuntivi

in alternativa possiamo puntare direttamente all’indirizzo: http://192.168.1.203:8080/Plone/prefs_install_products_form

Selezioniamo il tema che abbiamo creato e attiviamolo con l’apposito tasto

Ora vedremo il sito Plone spogliato di tutti i fogli di stile:

Brutta sorpresa direte, visto che prima abbiamo scelto di non sovrascrivere i css originari.

Con Plene 3 avrei avuto il risultato voluto ma con Plone 4 c’è ancora un passaggio da fare.

Il tema che abbiamo trovato inizialmente su Plone 4 si chiama Sunburst Theme ma in Plone 3 il tema di default si chiamava Plone Default. Il vecchio tema è ancora disponibile ma ora in Plone 4 si chiama Plone Classic Theme.

Il tema che abbiamo creato dunque va adattato a Plone 4.

Basta modificare il file che troviamo in src/plonetheme.testplone4/plonetheme/testplone4/profiles/default/skins.xml in questo modo:

Originale
<skin-path name="Tema Test Plone4" based-on="Plone Default">
Modificato
<skin-path name="Tema Test Plone4" based-on="Sunburst Theme">

Una volta salvata la modifica dovremo riavviare il server Zope per vederne l’effetto.

Ora vediamo come personalizzare il tema che abbiamo creato.

Gli strumenti che ci servono sono:

  • Firefox ed il plugin Firebug
  • Un buon editor (Komodo per esempio), magari che supporti l’editazione di file remoti
  • Eventualmente un Grid System (deco.gs per esempio) per aiutarci nello sviluppo

Il primo lavoro che dovremo fare e’ copiare brutalmente i fogli di stile utilizzati dal tema SunBurst nel nostro tema, per poterli poi modificare a piacere.

Per fare questo in modo semplice creiamo in ubuntu 2 variabili di sistema temporanee partendo dalla directory principale di Plone4 (nel nostro caso ~/plone402):

cd ~/plone402
orig=`cat bin/instance | grep "plonetheme.sunburst" | cut -d \' -f2`/plonetheme/sunburst/skins/sunburst_styles
dest=src/plonetheme.testplone4/plonetheme/testplone4/skins/plonetheme_testplone4_styles/

Verifichiamo i valori memorizzati con:

echo $orig
echo $dest

e copiamo i file da modificare:

cp $orig/ploneCustom.css.dtml $dest
cp $orig/public.css $dest

Ora col nostro editor di testo possiamo modificare a piacere questi files.

Possiamo pensare di modificare public.css quando volgiamo modificare dei tag esistenti e inserire eventuali tag nuovi nel file ploneCustom.css.dtml ma questa scelta è arbitraria. L’importante è sapere che ploneCustom.css.dtml ha la precedenza su public.css.

(work in progress….)

Installazione Plone 4.0.2 su Ubuntu server 10.04LTS

Ecco come installare l’ultima versione di Plone (4.0.2) in un sistema Ubuntu minimale (installato in una virtual machine tramite l’immagine mini.iso ver 10.04 a 32bit).

Inizia l’installazione di Ubuntu

Scelgo la lingua:

Do un nome al server:

Partiziono come consigliato:

Nel nostro caso bastano le partizioni essenziali:

Imposto gli aggiornamenti automatici relativi alla sicurezza:

Scelgo di installare solo i componenti essenziali e il servizio ssh

Termino la procedura con l’installazione di Grub

Una volta che il server ha terminato l’installazione e si sarà riavviato, scopriamo l’indirizzo ip assegnato dinamicamente dal server DHCP:

ifconfig eth0

Ora dal nostro PC possiamo accedere al server virtuale tramite ssh:

ssh fc@192.168.1.203

(anche Putty va bene se abbiamo solo Windows a disposizione)

Ora possiamo installare i pacchetti che serviranno a Plone4.
Nota bene: tutti i comandi vanno eseguiti come utente normale, non quindi da root, quando serviranno i privilegi di root verrà specificato di eseguirli tramite sudo

sudo aptitude install build-essential python-dev python-pip python-pastescript python-setuptools python-imaging subversion

Installiamo ora i componenti che ci servono per installare rapidamente i progetti Zope

sudo pip install zopeskel

Possiamo ora utilizzare paster per installare Plone. Diamo un’occhiata per vedere quali template sono disponibili:

paster create --list-templates
Available templates:
 archetype:          A Plone project that uses Archetypes content types
 basic_namespace:    A basic Python project with a namespace package
 basic_package:      A basic setuptools-enabled package
 basic_zope:         A Zope project
 kss_plugin:         A project for a KSS plugin
 nested_namespace:   A basic Python project with a nested namespace (2 dots in name)
 paste_deploy:       A web application deployed through paste.deploy
 plone:              A project for Plone products
 plone2.5_buildout:  A buildout for Plone 2.5 projects
 plone2.5_theme:     A theme for Plone 2.5
 plone2_theme:       A theme for Plone 2.1
 plone3_buildout:    A buildout for Plone 3 installation
 plone3_portlet:     A Plone 3 portlet
 plone3_theme:       A theme for Plone 3
 plone_app:          A project for Plone products with a nested namespace (2 dots in name)
 plone_hosting:      Plone hosting: buildout with ZEO and Plone versions below 3.2
 plone_pas:          A project for a Plone PAS plugin
 recipe:             A recipe project for zc.buildout
 silva_buildout:     A buildout for Silva projects

Utilizziamo il template plone3_buildout visto che non c’e’ ancora un template specifico per Plone4

paster create -t plone3_buildout

Alle domande che ci vengono poste rispondiamo nel modo seguente

Enter project name: plone402
Expert Mode? (What question mode would you like? (easy/expert/all)?) ['easy']: easy
Plone Version (Plone version # to install) ['3.3.5']: 4.0.2
Zope2 Install Path (Path to Zope2 installation; leave blank to fetch one!) ['']:
Plone Products Directory (Path to Plone products; leave blank to fetch [Plone 3.0/3.1 only]) ['']:
Initial Zope Username (Username for Zope root admin user) ['admin']: admin
Initial User Password (Password for Zope root admin user) ['']: admin
HTTP Port (Port that Zope will use for serving HTTP) ['8080']:
Debug Mode (Should debug mode be "on" or "off"?) ['off']: on
Verbose Security? (Should verbose security be "on" or "off"?) ['off']: off

Per il passaggio successivo ci servirà anche il pacchetto distribute

sudo easy_install distribute==0.6.14

Entriamo nella cartella creata in precedenza:

cd plone402/

Lanciamo lo script bootstrap.py

python bootstrap.py

Alla fine otterremo la risposta: Generated script ‘/home/fc/plone402/bin/buildout’.

Ora scarichiamo tutti i pacchetti e le dipendenze indicate nel file buildout.cfg col comando:

./bin/buildout

Questo è il passaggio più lungo ma anche l’ultimo 😉

Ora avviamo il server Zope

./bin/instance console

Nota: è ancora possibile avviare il server tramite il comando ./bin/instance fg ma dalla versione 4 si consiglia di utilizzare ./bin/instance console

Se vogliamo avviare il server in modalità background scriveremo: ./bin/instance start

e col nostro Browser verifichiamo il funzionamento di Plone puntando all’indirizzo: http://192.168.1.203:8080 (sostituite all’occorrenza il numero IP con quello del vostro server):

Questo post è stato riadattato dall’originale di Noe Misael Nieto Arroyo

Nel prossimo articolo vedremo come creare un nostro tema per Plone 4

Plone Backup e Ftp con pipe

Ecco come ho preparato un comodo script per fare il backup dell’archivio di Plone e subito dopo copiare il backup compresso con TAR in un server FTP senza lasciare nel webserver il file tgz

#!/bin/bash

PLONEPATH="/home/zope/plone32" # where you have your buildout.cfg
REPOZOPATH="${PLONEPATH}/bin/repozo"
DATAFSPATH="${PLONEPATH}/var/filestorage/Data.fs"
DESTINATION="/home/zope/backup/repozo"
DBBACKUP="${REPOZOPATH} -BzQ -r ${DESTINATION} -f ${DATAFSPATH}"
FTP_SERVER_IP="192.168.1.21"
FTP_DESTINATION="dir1/subdir1"
PYTHONPATH="${PLONEPATH}/parts/zope2/lib/python"

export PYTHONPATH # otherwise repozo.py will probably not be able to find its libraries

DATA=`expr $(date +%d)`
RESTO=`expr ${DATA} % 2` # 2 set backup, on even and odd days
DIRNAME_DESTINATION=`dirname ${DESTINATION}`
BASENAME_DESTINATION=`basename ${DESTINATION}`

`${DBBACKUP}`

ftp -n ${FTP_SERVER_IP} <<ENDSCRIPT
user ftp_user ftp_password
binary
put "| /bin/tar -czf - -C ${DIRNAME_DESTINATION} ${BASENAME_DESTINATION}" ${FTP_DESTINATION}/backup_${RESTO}.tgz
bye
ENDSCRIPT