Crear un Servidor para Contactos y Calendarios

Requisitos:

• Una IP pública estática
• Un servidor Linux
• Un dominio

Para asegurar un flujo de datos seguro y sin interrupciones, esta guía utiliza un dominio registrado en gandi.net (por su interfaz simple y política de "No Bullshit"). Normalmente y en cualquier registrador, los dominios tienen precios accesibles y se puede optar por dominios .com, .org, .cc, .net, etc., o dominios específicos de un país, y pueden ser de utilidad para múltiples proyectos.

Para obtener una IP pública estática y un servidor Linux, es posible utilizar los servicios de oracle.com/cloud/ a través de la opción "Try OCI for free".

Nota: Para registrar una cuenta gratuita en Oracle Cloud, es necesario proporcionar información de una persona real, incluyendo una tarjeta que valide al usuario, y una vez creada, se tiene acceso hasta 4 servidores Linux de forma gratuita , Oracle no hará ningún cobro a menos que se solicite explícitamente cambiar a una cuenta de pago.

Usuarios y Passwords utilizados:

Esta es una lista de usuarios y passwords que se crean durante la instalación:

1. User y Password para los servicios VPS Linux (Oracle Cloud OCI en los ejemplos).
2. User y Password para el registrador de dominios (gandi.net en los ejemplos).
3. User y Password para Radicale (usuario1 en los ejemplos).
4. Password para la Clave SSH (para ingresar al servidor Linux con el usuario pruebauser).
5. User y Password para el nuevo usuario de Linux (pruebauser en los ejemplos).
6. Usuario específico para ejecutar Radicale de forma más segura (usuario_restringido en los ejemplos).

Nota: Para facilitar la administración, se recomienda utilizar un gestor de passwords como KeepassXC.

Crear la llave SSH en Linux desde la terminal:

 
#1. Crear la llave SSH con el nombre "server" (Usar cualquier nombre o el nombre por defecto). 
ssh-keygen -o -t rsa -b 4096 -f ~/.ssh/server

#2. Solicitará agregar una contraseña cualquiera (normalmente una nueva) y luego confirmarla.       
#3. Se crea en la carpeta ~/.ssh la Clave privada (server) y la Clave pública (server.pub).  
#4. Consultar la llave SSH.            
cat ~/.ssh/server.pub

En Windows se pueden utilizar herramientas como PuTTY, WSL o incluso una máquina virtual con Linux. Sin embargo, se recomienda instalar Git SCM y utilizar su herramienta Git Bash:

https://git-scm.com/downloads/win (64-bit Git for Windows Setup)

La guía utiliza nano como editor de texto. Durante la instalación de Git SCM, hay una sección para elegir entre Vim y otros, se puede elegir nano.

Crear la llave SSH en Git Bash:

 
#1. Crear la llave SSH con el nombre "server" (Usar cualquier nombre o el nombre por defecto). 
ssh-keygen -o -t rsa -b 4096 -f ~/.ssh/server 

#2. Solicitará agregar una contraseña cualquiera (normalmente una nueva) y luego confirmarla.    
#3. Consultar la llave SSH para copiar y utilizar en Oracle Cloud.            
cat ~/.ssh/server.pub


#En Windows los archivos Clave privada (server) y la Clave pública (server.pub)
se crearon en C:/Users/USUARIO/.ssh/ 

Crear una instancia OCI:

Una vez creada la cuenta en Oracle Cloud se inicia sesion.

1. Ir al menú de opciones.
2. Seleccionar "Instancias".

1. Seleccionar la raíz.
2. Crear instancia.

1. Agregar un nombre (el nombre del host).
2. Cambiar la imagen de Linux.

1. Seleccionar Ubuntu.
2. Seleccionar la versión.
3. Seleccionar imagen.

1. Verificar si la red está creada, si no es así, crearla.
2. Seleccionar "Pegar claves públicas".
3. Agregar la clave SSH creada y copiada anteriormente.
4. Crear.

1. Controles de la instancia OCI (la máquina virtual Linux). Con el botón "Terminar" se puede eliminar la instancia.
2. Obtenemos la IP pública estática.
3. Obtenemos el usuario de la instancia llamado "ubuntu" (es el usuario del servidor Linux, más adelante se cambia por seguridad).

Abrir puertos en las configuraciones de red de Oracle Cloud:

1. Buscar " Default Security List ".
2. Hacer clic en la Subred encontrada.

1. Agregar reglas de entrada.
2. CIDR de origen: 0.0.0.0/0
3. Protocolo IP: TCP.
4. Rango de puertos de destino: 80,443.
5. Agregar reglas de entrada.

En el ejemplo con gandi.net, después de adquirir un dominio ingresar a la pantalla principal.

1. Ir a Dominio.
2. Hacer clic en el dominio.

1. Ir a Zonas DNS.
2. Add record.

1. Seleccionar tipo A.
2. Normalmente se utiliza un TTL de 3600 (1 hora).
3. Agregar cualquier nombre de subdominio, en el ejemplo se utiliza "radicale".
4. Agregar la IP pública obtenida de Oracle Cloud.
5. Crear.

Ingresar al servidor desde el cliente con la terminal:

 
#1. Colocar el comando especificando la clave pública con el usuario y la IP pública. 
ssh -i ~/.ssh/server ubuntu@168.138.92.191

#2. Escribir "yes".       
#3. Agregar la contraseña de la clave SSH.
#4. Ahora se ha ingresado al servidor Linux.

Crear un usuario nuevo y eliminar el usuario por defecto "ubuntu" creado por Oracle Cloud OCI:

 
#1. Crear usuario, en el ejemplo se llama "pruebauser". 
sudo adduser pruebauser

#2. Agregar una nueva contraseña para el usuario nuevo y repetir.       
#3. Se puede dejar en blanco o agregar información.
#4. Se agrega el usuario al grupo de sudo.
sudo usermod -aG sudo pruebauser

#4. Copiar la carpeta con la Clave Pública SSH al nuevo usuario para permitir su ingreso.
sudo cp -r /home/ubuntu/.ssh /home/pruebauser/

#4. Se le agregan los permisos del usuario nuevo a la carpeta copiada.
sudo chown -R pruebauser:pruebauser /home/pruebauser/.ssh

#5. "exit" dos veces para salir completamente e iniciar sesión con el nuevo usuario.
#6. Iniciar con el nuevo usuario, se utiliza el password para la Clave SSH.
ssh -i ~/.ssh/server pruebauser@168.138.92.191

 
#Eliminar el usuario "ubuntu".
#Usar sudo con el password del nuevo usuario.
sudo userdel -f ubuntu
sudo rm -r /home/ubuntu

Cambiar la zona horaria:

 
#Buscar el nombre correcto de la zona horaria (Ctrl+c para salir).
sudo timedatectl list-timezones

#Cambiar la zona horaria.
sudo timedatectl set-timezone America/Costa_Rica

Actualizar e instalar herramientas básicas:

 
#Actualizar Linux.
sudo apt update && apt upgrade -y

#Instalar nano, rsyslog y el framework para el Firewall (normalmente ya instalado).
sudo apt install nano rsyslog netfilter-persistent iptables-persistent -y

Abrir puerto 80 (http) y 443 (https) en el servidor Linux:

#Abrir puertosnen el servidor Linux:
sudo iptables -I INPUT 6 -m state --state NEW -p tcp --match multiport --dports 80,443 -j ACCEPT

#Hacer la regla persistente:
sudo netfilter-persistent save

Instalar herramientas:

 
sudo apt install radicale apache2-utils certbot python3-certbot-nginx nginx -y

Habilitar Radicale:

 
#Habilitar.
sudo systemctl enable radicale

#Iniciar.
sudo systemctl start radicale

#Verificar (ctrl+c para salir).
sudo systemctl status radicale

Configurar Radicale:

 
#Respaldar el archivo config.
sudo mv /etc/radicale/config /etc/radicale/config.backup

#Crear y abrir con nano el archivo config.
sudo nano /etc/radicale/config

#Copiar y pegar el siguiente contenido en el archivo abierto con nano:
[server]
hosts = 127.0.0.1:5232
max_connections = 20
max_content_length = 100000000
timeout = 30

[auth]
type = htpasswd
htpasswd_filename = /etc/radicale/users
htpasswd_encryption = bcrypt
delay = 5

[rights]
type = from_file
file = /etc/radicale/rights

[storage]
filesystem_folder = /var/lib/radicale/collections
max_sync_token_age = 2592000

[logging]
level = warning
mask_passwords = True

# Ctrl+s guardar.
# Ctrl+x salir de nano.

 
#Respaldar el archivo rights.
sudo mv /etc/radicale/rights /etc/radicale/rights.backup

#Definir los permisos de acceso a las colecciones.
sudo nano /etc/radicale/rights

#Copiar y pegar el siguiente contenido en el archivo abierto con nano:
#Agregar un usuario admin para Radicale, en el ejemplo se llama "usuario1"
[root]
user: .+
collection:
permissions: R

[principal]
user: .+
collection: {user}
permissions: RW

[calendars]
user: .+
collection: {user}/[^/]+
permissions: rw

[admin]
user: ^usuario1$
collection: .*
permissions: rw

[user-rights]
user: ^.+$
collection: {user}/.*
permissions: rw

Agregar usuarios:

  
# Crear el archivo cifrado con un usuario, en el ejemplo usuario1. 
# Agregar contraseña y repetir. 
sudo htpasswd -Bc /etc/radicale/users usuario1

# Si se desea agregar otros usuarios, quitar la bandera "-c". 
sudo htpasswd -B /etc/radicale/users nuevo_usuario 
 

Configuración segura de Radicale con usuario restringido:

 
#Configura un usuario específico para ejecutar Radicale de forma más segura.
sudo adduser --system --group --disabled-login usuario_restringido

#Edita/crear el archivo del servicio.
sudo nano /etc/systemd/system/radicale.service
[Unit]
Description=A simple CalDAV (calendar) and CardDAV (contact) server
After=network.target

[Service]
User=usuario_restringido
Group=usuario_restringido
ExecStart=/usr/bin/radicale --config /etc/radicale/config
Restart=on-failure

[Install]
WantedBy=multi-user.target

#Cambia la propiedad de los directorios.
sudo chown -R usuario_restringido:usuario_restringido /etc/radicale /var/lib/radicale /var/log/radicale

#Permisos de los directorios restrictivos.
sudo chmod -R 750 /etc/radicale /var/lib/radicale /var/log/radicale

#Reiniciar el demonio.
sudo systemctl daemon-reload

#Habilitar.
sudo systemctl enable radicale

#Iniciar.
sudo systemctl restart radicale

#Verificar (ctrl+c para salir).
sudo systemctl status radicale

Crear Certificados para el Dominio con Let's Encrypt:

 

#Antes de generar los certificados, verificar que hay acceso al dominio. 
host radicale.varlogsys.com 

#El comando anterior debería devolver la IP Pública. 
 

 
#1. Generar certificados para el dominio.
sudo certbot --nginx -d radicale.varlogsys.com

#2. Agregar un email cualquiera.
#3. Aceptar con "y".
#4. Aceptar con "y".
 

#Las renovaciones de certificados de Let's Encrypt ya están automatizadas.

Configuración de Nginx y Reverse Proxy:

 
#Archivo de configuración de Nginx para el dominio radicale.varlogsys.com. Abrir con nano.
sudo nano /etc/nginx/sites-available/radicale.varlogsys.com
server {
    listen 443 ssl http2;
    server_name radicale.varlogsys.com;

    ssl_certificate /etc/letsencrypt/live/radicale.varlogsys.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/radicale.varlogsys.com/privkey.pem;

    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_prefer_server_ciphers on;
    ssl_ciphers "ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384";
    ssl_session_cache shared:SSL:10m;
    ssl_session_timeout 10m;
    ssl_dhparam /etc/nginx/dhparam.pem;

    # Configuración de seguridad adicional
    add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" always;
    add_header X-Frame-Options DENY;
    add_header X-Content-Type-Options nosniff;
    add_header X-XSS-Protection "1; mode=block";
    
    # Logs específicos para Radicale
    access_log /var/log/nginx/radicale_access.log;
    error_log /var/log/nginx/radicale_error.log;

    location / {
        proxy_pass http://127.0.0.1:5232;
        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;
    }
}

# Redirigir tráfico HTTP a HTTPS
server {
    listen 80;
    server_name radicale.varlogsys.com;
    return 301 https://$server_name$request_uri;
}


#Generar un grupo Diffie-Hellman para mejorar la seguridad SSL. (Puede durar minutos)
sudo openssl dhparam -out /etc/nginx/dhparam.pem 2048

#Enlazar la nueva configuración y recargar Nginx.

sudo ln -s /etc/nginx/sites-available/radicale.varlogsys.com /etc/nginx/sites-enabled/

sudo nginx -t

sudo unlink /etc/nginx/sites-enabled/default

sudo systemctl restart nginx

sudo systemctl restart radicale

#El servidor Radicale ahora funciona, ingresar al sitio, en el ejemplo radicale.varlogsys.com

Ver logs:

 
 
sudo journalctl -u radicale.service

sudo journalctl -u nginx.service

sudo tail /var/log/nginx/error.log

sudo tail /var/log/nginx/access.log
 

Respaldar todos los contactos y calendarios:

 
 
#Crear el archivo de respaldo llamado radicale_backup.tar.gz

sudo tar -cvzf /home/pruebauser/radicale_backup.tar.gz /var/lib/radicale/collections /etc/radicale/users

sudo chown pruebauser:pruebauser /home/pruebauser/radicale_backup.tar.gz


#Ejecutar lo siguiente en la PC cliente si se desea descargar el respaldo desde el servidor al cliente:

scp -i ~/.ssh/server pruebauser@168.138.92.191:/home/pruebauser/radicale_backup.tar.gz ~/
 

Restaurar/subir todos los contactos y calendarios:

 
 
#Ejecutar lo siguiente en la PC cliente si se desea subir el archivo desde cliente al servidor:

scp -i ~/.ssh/server ~/radicale_backup.tar.gz pruebauser@168.138.92.191:~/


#Este comando descomprimirá los archivos del respaldo directamente en sus ubicaciones originales

sudo tar -xvzf radicale_backup.tar.gz -C /


#Ajustar los permisos

sudo chown -R usuario_restringido:usuario_restringido /etc/radicale /var/lib/radicale

sudo chmod -R 750 /etc/radicale /var/lib/radicale

sudo chmod 640 /etc/radicale/users
 

Configurar los servicios con Docker:

 
#Instalar docker, certbot, htpasswd y crear los contenedores Radicale y Nginx.

sudo apt install docker.io docker-compose certbot apache2-utils -y

mkdir -p ~/radicale/data ~/radicale/config ~/radicale/auth

nano ~/radicale/docker-compose.yml

#Copiar y pegar el siguiente contenido en el archivo abierto con nano:
version: '3'

services:
  radicale:
    image: tomsquest/docker-radicale:latest
    container_name: radicale
    ports:
      - "127.0.0.1:5232:5232"
    volumes:
      - ./data:/data
      - ./config:/config
      - ./auth:/auth
    environment:
      - UID=1000
      - GID=1000
    restart: unless-stopped
    networks:
      - radicale_network

  nginx:
    image: nginx:alpine
    container_name: radicale_nginx
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./config/nginx.conf:/etc/nginx/nginx.conf:ro
      - /etc/letsencrypt:/etc/letsencrypt:ro
      - /var/log/nginx:/var/log/nginx
      #- ./auth:/auth
    depends_on:
      - radicale
    networks:
      - radicale_network
    restart: unless-stopped

networks:
  radicale_network:
    driver: bridge


nano ~/radicale/config/config

#Copiar y pegar el siguiente contenido en el archivo abierto con nano:
[server]
hosts = 0.0.0.0:5232

[auth]
type = htpasswd
htpasswd_filename = /auth/htpasswd
htpasswd_encryption = bcrypt

[rights]
type = owner_only

[storage]
type = multifilesystem
filesystem_folder = /data

nano ~/radicale/config/nginx.conf

#Copiar y pegar el siguiente contenido en el archivo abierto con nano:
events {}

http {
    server {
        listen 80;
        server_name radicale.varlogsys.com;

        # Redirección HTTP a HTTPS
        location / {
            return 301 https://$host$request_uri;
        }
    }

    server {
        listen 443 ssl;
        server_name radicale.varlogsys.com;

        ssl_certificate /etc/letsencrypt/live/radicale.varlogsys.com/fullchain.pem;
        ssl_certificate_key /etc/letsencrypt/live/radicale.varlogsys.com/privkey.pem;

        # Cabeceras de seguridad
        add_header Strict-Transport-Security "max-age=31536000; includeSubDomains; preload" always;
        add_header X-Frame-Options "DENY" always;
        add_header Content-Security-Policy "default-src 'self'; script-src 'self' 'unsafe-inline'; style-src 'self' 'unsafe-inline';" always;

        access_log /var/log/nginx/radicale_access.log;
        error_log /var/log/nginx/radicale-error.log;


        location / {
            proxy_pass http://radicale:5232/;
            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;
        }

        # Autenticación básica desde nginx (Tiene que ver con - ./auth:/auth del docker-compose.yml)
        # auth_basic "Restricted Content";
        # auth_basic_user_file /auth/htpasswd;
    }
}

#Crea el usuario1:
htpasswd -Bc ~/radicale/auth/htpasswd usuario1

#Añadir un usuario nuevo:
htpasswd -B ~/radicale/auth/htpasswd newuser

#Antes de generar los certificados, verificar que hay acceso al dominio. 
host radicale.varlogsys.com 
#El comando anterior debería devolver la IP Pública. 

#Generar certificados para el dominio:
sudo certbot certonly --standalone -d radicale.varlogsys.com

#Iniciar/crear los contenedores Docker:
sudo docker-compose -f ~/radicale/docker-compose.yml up -d

 
#Muestra los contenedores Docker:
sudo docker ps

#Detener/borrar los contenedores:
sudo docker-compose -f ~/radicale/docker-compose.yml down

#Iniciar/crear los contenedores:
sudo docker-compose -f ~/radicale/docker-compose.yml up -d

#Muestra los registros (logs) de los contenedores :
sudo docker logs radicale_nginx && sudo docker logs radicale

  
#Crear el archivo de respaldo llamado radicale_docker_backup.tar.gz

tar -cvzf ~/radicale_docker_backup.tar.gz ~/radicale/data ~/radicale/auth


#Ejecutar lo siguiente en la PC cliente si se desea descargar el respaldo desde el servidor al cliente:

scp -i ~/.ssh/server pruebauser@168.138.92.191:/home/pruebauser/radicale_docker_backup.tar.gz ~/ 
 

  
#Ejecutar lo siguiente en la PC cliente si se desea subir el archivo desde cliente al servidor: 

scp -i ~/.ssh/server ~/radicale_docker_backup.tar.gz pruebauser@168.138.92.191:/home/pruebauser/ 


#Descomprimir los archivos del respaldo en los volúmenes montados (con los contenedores detenidos):

tar -xvzf ~/radicale_docker_backup.tar.gz -C ~/ 


#Permisos de los volúmenes:

chown -R pruebauser ~/radicale/data ~/radicale/auth


#Iniciar los contenedores de Docker

sudo docker-compose -f ~/radicale/docker-compose.yml up -d