Servicios de red, configuración de servidores y automatización (RSA-15)

La ruta del SysAdmin 15 de jul. de 2025

Este apartado está dividido por tipo de servicio y uso:

Servicios y Configuración:
- Servidores web (Apache, Nginx)
- Servidores de archivos (FTP, Samba)
- DNS local y resolución
- Acceso remoto (SSH, VNC)
- Correo básico (Postfix)
Certificados SSL y CA
Automatización con Ansible

1. Servidor web: Apache

Instalación y activación

# apt install apache2
# systemctl enable apache2
# systemctl start apache2

Ver estado:

$ systemctl status apache2

Configuración básica

Editar /etc/apache2/sites-available/000-default.conf:

DocumentRoot /var/www/html
ServerName midominio.local

Recargar cambios:

# systemctl reload apache2

2. Servidor web: Nginx

Instalación y activación

# apt install nginx
# systemctl enable nginx
# systemctl start nginx

Configuración básica

Editar /etc/nginx/sites-available/default:

server {
    listen 80;
    server_name localhost;
    root /var/www/html;
}

Verificar y recargar:

# nginx -t
# systemctl reload nginx

3. Servidor FTP con vsftpd

Instalación y activación

# apt install vsftpd
# systemctl enable vsftpd
# systemctl start vsftpd

Configuración básica

Editar /etc/vsftpd.conf:

anonymous_enable=NO
local_enable=YES
write_enable=YES
chroot_local_user=YES

Reiniciar servicio:

# systemctl restart vsftpd

4. Compartición de archivos con Samba

Instalación

# apt install samba

Definir recursos en `/etc/samba/smb.conf`

[documentos]
    path = /home/luisgulo/Documentos
    browseable = yes
    read only = no
    guest ok = yes

Crear usuario Samba

# smbpasswd -a luisgulo
# systemctl restart smbd

Acceso desde otro equipo:

$ smbclient //server/documentos -U luisgulo

5. Configuración de DNS local con BIND

Instalación

# apt install bind9

Archivo de zona en `/etc/bind/db.local`

@ IN SOA ns1.midominio.local. admin.midominio.local. (
    2025071401 ; Serial
    3600       ; Refresh
    1800       ; Retry
    604800     ; Expire
    86400 )    ; TTL

@ IN NS ns1.midominio.local.
@ IN A 192.168.1.10

Activar servicio

# systemctl enable bind9
# systemctl start bind9

Consultar resolución:

$ dig @localhost midominio.local

6. Acceso remoto con SSH

Instalación y activación

# apt install openssh-server
# systemctl enable ssh
# systemctl start ssh

Claves públicas

$ ssh-keygen
$ ssh-copy-id luisgulo@servidor

Configuración segura

Editar /etc/ssh/sshd_config:

PermitRootLogin no
PasswordAuthentication no
MaxAuthTries 3

7. Escritorio remoto con VNC (ejemplo con TigerVNC)

# apt install tigervnc-standalone-server
$ vncserver

Acceso desde otro equipo:

$ vncviewer servidor:1

Configurar resolución y usuario en ~/.vnc/xstartup

8. Servidor de correo simple con Postfix

Instalación

# apt install postfix mailutils

Modo recomendado: "Sitio de Internet"

Enviar correo desde terminal

$ echo "Prueba de correo" | mail -s "Asunto" luisgulo@soloconlinux.org.es

Ver logs:

$ tail -f /var/log/mail.log

Configuración de certificados SSL

Los certificados SSL/TLS permiten cifrar la comunicación entre el servidor y los clientes. Hoy en día son esenciales para cualquier servicio público (HTTP, correo, VPN…) y también recomendables en entornos internos.

1. Generar certificado autofirmado con OpenSSL

Útil para entornos de pruebas o privados.

# mkdir /etc/ssl/private
# openssl req -x509 -nodes -days 365 -newkey rsa:2048 \
  -keyout /etc/ssl/private/servidor.key \
  -out /etc/ssl/private/servidor.crt

Solicita datos como país, nombre de host, empresa…

2. Configurar Apache con SSL

Activar el módulo SSL y el sitio HTTPS:

# a2enmod ssl
# a2ensite default-ssl
# systemctl reload apache2

Editar /etc/apache2/sites-available/default-ssl.conf:

SSLEngine on
SSLCertificateFile      /etc/ssl/private/servidor.crt
SSLCertificateKeyFile   /etc/ssl/private/servidor.key

Redirigir HTTP a HTTPS:

En 000-default.conf:

<VirtualHost *:80>
  RewriteEngine On
  RewriteRule ^(.*)$ https://%{SERVER_NAME}$1 [R=301,L]
</VirtualHost>

3. Configurar Nginx con SSL

Editar archivo de configuración (default o sitio.conf):

server {
    listen 443 ssl;
    server_name midominio.com;

    ssl_certificate     /etc/ssl/private/servidor.crt;
    ssl_certificate_key /etc/ssl/private/servidor.key;

    root /var/www/html;
}

Redirigir HTTP a HTTPS:

server {
    listen 80;
    server_name midominio.com;
    return 301 https://$host$request_uri;
}

Verificar y recargar:

# nginx -t
# systemctl reload nginx

4. Obtener certificado gratuito con Let's Encrypt (Certbot)

Instalación del cliente Certbot:

# apt install certbot python3-certbot-apache      # Para Apache
# apt install certbot python3-certbot-nginx       # Para Nginx

Solicitar certificado:

# certbot --apache
# certbot --nginx

Certbot configura automáticamente redirecciones y renovación automática.

Renovar manualmente:

# certbot renew

Verificar expiración:

# openssl x509 -in servidor.crt -noout -enddate

5. Seguridad adicional en SSL/TLS

Recomendaciones:

Usa claves de al menos 2048 bits
Desactiva protocolos inseguros como SSLv2/v3 y TLS < 1.2
Usa encabezados de seguridad: HSTS, X-Frame-Options
Usa herramientas como ssllabs.com para analizar tu configuración

Firma de certificados con una CA propia y automatización de emisión

Este procedimiento incluye:

Crear una CA interna con OpenSSL
Generar certificados y firmarlos con la CA
Instalar certificados en servicios como Apache o Nginx
Automatizar emisión y renovación con scripts

1. Crear tu propia CA

# mkdir -p ~/miCA/{private,certs,newcerts,crl}
# chmod 700 ~/miCA/private
# touch ~/miCA/index.txt
# echo 1000 > ~/miCA/serial

Crear clave privada de la CA:

# openssl genrsa -aes256 -out ~/miCA/private/ca.key.pem 4096

Generar certificado raíz:

# openssl req -x509 -new -nodes -key ~/miCA/private/ca.key.pem \
  -days 3650 -out ~/miCA/certs/ca.cert.pem

Este certificado es la raíz para firmar otros certificados.

2. Generar certificado para un servidor

Crear clave y CSR (solicitud de firma):

# openssl genrsa -out servidor.key.pem 2048
# openssl req -new -key servidor.key.pem -out servidor.csr.pem

Firmar con la CA:

# openssl x509 -req -in servidor.csr.pem \
  -CA ~/miCA/certs/ca.cert.pem -CAkey ~/miCA/private/ca.key.pem \
  -CAcreateserial -out servidor.cert.pem -days 365 -sha256

→ Ahora tienes el certificado (servidor.cert.pem) y su clave (servidor.key.pem) listos.

3. Instalar certificado en Apache o Nginx

Apache:

SSLCertificateFile      /etc/ssl/servidor.cert.pem
SSLCertificateKeyFile   /etc/ssl/servidor.key.pem
SSLCertificateChainFile /etc/ssl/ca.cert.pem

Nginx:

ssl_certificate         /etc/ssl/servidor.cert.pem;
ssl_certificate_key     /etc/ssl/servidor.key.pem;
ssl_trusted_certificate /etc/ssl/ca.cert.pem;

4. Automatizar emisión y renovación

Crear script /usr/local/bin/emitir_certificado.sh:

#!/bin/bash

DOMINIO=$1
CADAYS=365
FECHA=$(date +%F)
CARPETA="/etc/ssl/$DOMINIO"

mkdir -p "$CARPETA"

openssl genrsa -out "$CARPETA/$DOMINIO.key.pem" 2048

openssl req -new -key "$CARPETA/$DOMINIO.key.pem" \
  -out "$CARPETA/$DOMINIO.csr.pem" -subj "/CN=$DOMINIO"

openssl x509 -req -in "$CARPETA/$DOMINIO.csr.pem" \
  -CA ~/miCA/certs/ca.cert.pem -CAkey ~/miCA/private/ca.key.pem \
  -CAcreateserial -out "$CARPETA/$DOMINIO.cert.pem" \
  -days $CADAYS -sha256

echo "Certificado emitido para $DOMINIO ($FECHA)"

5. Programar renovación automática

Agregar a crontab del sistema:

$ crontab -e
0 2 * * * /usr/local/bin/emitir_certificado.sh midominio.local

→ Renovará el certificado cada noche a las 2:00. Puedes usar lógica condicional para renovar sólo si la fecha de expiración está próxima.

Consultar expiración:

$ openssl x509 -in servidor.cert.pem -noout -enddate

Recomendaciones

Protege la clave privada de la CA: debe tener acceso restringido
No uses una CA propia en servicios públicos sin configurar los clientes para confiar en ella
Distribuye el certificado raíz (ca.cert.pem) a los clientes para evitar advertencias de navegador

Es importante entender la estructura de una CA interna y sus directorios, sus archivos clave, los scripts para emisión, revocación, verificación de certificados, y seguimiento del historial.

Esta arquitectura se puede usar para firmar certificados de servidores web, correo, VPN u otros servicios internos.

Autoridad Certificadora (CA) interna: estructura completa y scripts

Esta sección incluye:

Estructura de directorios estandarizada
Generación de claves y certificado raíz
Scripts para emitir, revocar, y consultar certificados
Buenas prácticas de protección y mantenimiento

1. Estructura de directorios de la CA

Supongamos que la CA vive en /opt/ca:

/opt/ca/
+---- certs/           # Certificados emitidos
+---- crl/             # Listas de revocación (CRL)
+---- newcerts/        # Copias de certificados firmados
+---- private/         # Clave privada de la CA
+---- csr/             # Solicitudes recibidas (CSR)
+---- issued/          # Certificados activos por dominio
+---- revoked/         # Certificados revocados
+---- scripts/         # Scripts automáticos
+---- index.txt        # Registro de certificados emitidos
+---- serial           # Número de serie actual
+---- openssl.cnf      # Configuración de OpenSSL para la CA

Archivos iniciales:

# mkdir -p /opt/ca/{certs,crl,newcerts,private,csr,issued,revoked,scripts}
# touch /opt/ca/index.txt
# echo 1000 > /opt/ca/serial

2. Archivo de configuración `openssl.cnf`

Ubicarlo en /opt/ca/openssl.cnf. Personalizar rutas:

[ ca ]
default_ca = CA_local

[ CA_local ]
dir             = /opt/ca
certificate     = $dir/certs/ca.cert.pem
private_key     = $dir/private/ca.key.pem
new_certs_dir   = $dir/newcerts
database        = $dir/index.txt
serial          = $dir/serial
default_days    = 365
default_md      = sha256
policy          = policy_match

[ policy_match ]
commonName      = supplied
countryName     = optional
stateOrProvinceName = optional
organizationName = optional
organizationalUnitName = optional
emailAddress    = optional

3. Crear clave y certificado raíz

openssl genrsa -aes256 -out /opt/ca/private/ca.key.pem 4096

openssl req -x509 -new -nodes -key /opt/ca/private/ca.key.pem \
  -days 3650 -out /opt/ca/certs/ca.cert.pem \
  -subj "/CN=CA de Luis/O=Red Interna/C=ES"

→ Protege ca.key.pem con permisos restrictivos:

chmod 400 /opt/ca/private/ca.key.pem

4. Script para emitir certificados (`scripts/emitir.sh`)

#!/bin/bash

DOMINIO=$1
DAYS=365
DIR=/opt/ca

mkdir -p $DIR/issued/$DOMINIO

openssl genrsa -out $DIR/issued/$DOMINIO/$DOMINIO.key.pem 2048

openssl req -new -key $DIR/issued/$DOMINIO/$DOMINIO.key.pem \
  -out $DIR/csr/$DOMINIO.csr.pem -subj "/CN=$DOMINIO"

openssl ca -config $DIR/openssl.cnf \
  -in $DIR/csr/$DOMINIO.csr.pem \
  -out $DIR/issued/$DOMINIO/$DOMINIO.cert.pem -days $DAYS -batch

echo "Certificado emitido para $DOMINIO"

Ejecutar:

chmod +x /opt/ca/scripts/emitir.sh
/opt/ca/scripts/emitir.sh servidor.local

5. Script para revocar certificados (`scripts/revocar.sh`)

#!/bin/bash
DOMINIO=$1
DIR=/opt/ca

openssl ca -config $DIR/openssl.cnf \
  -revoke $DIR/issued/$DOMINIO/$DOMINIO.cert.pem

openssl ca -config $DIR/openssl.cnf \
  -gencrl -out $DIR/crl/ca.crl.pem

mv $DIR/issued/$DOMINIO/ $DIR/revoked/$DOMINIO/
echo "Certificado revocado: $DOMINIO"

6. Verificar expiración de un certificado

openssl x509 -in /opt/ca/issued/servidor.local/servidor.local.cert.pem -noout -enddate

7. Script de renovación automática (`scripts/renovar.sh`)

#!/bin/bash
DOMINIO=$1
DAYS=365
DIR=/opt/ca

FECHA=$(openssl x509 -in $DIR/issued/$DOMINIO/$DOMINIO.cert.pem -noout -enddate | cut -d= -f2)
EXPIRA=$(date -d "$FECHA" +%s)
HOY=$(date +%s)
DIAS_RESTANTES=$(( (EXPIRA - HOY) / 86400 ))

if [ "$DIAS_RESTANTES" -lt 15 ]; then
    echo "Renovando certificado $DOMINIO (expira en $DIAS_RESTANTES días)"
    /opt/ca/scripts/emitir.sh $DOMINIO
else
    echo "Certificado $DOMINIO aún válido ($DIAS_RESTANTES días)"
fi

→ Se puede agendar por cron para revisar diariamente.

8. Configuración recomendada

Protege /opt/ca/private/ con permisos chmod 700
Realiza backups cifrados periódicos de la CA
No expongas esta CA a la red pública; distribuye ca.cert.pem solo en clientes autorizados
Usa controles de acceso y auditoría sobre los scripts

Para finalizar la gestión de certificados con CA propia, podemos tambien cubrir tres aspectos:

Validar la cadena completa desde cliente
Revocación desde navegador
Integración de tu CA en una VPN interna (ej. OpenVPN)

Validación completa de la cadena desde cliente

Si un cliente (máquina o navegador) necesita confirmar que un certificado es válido y ha sido emitido por tu CA, puedes usar este script para verificar:

Script `validar_cert.sh`

#!/bin/bash

CERT=$1             # certificado del servidor
CA=$2               # certificado de la CA raíz
CRL=$3              # lista de revocación opcional

echo "Validando certificado: $CERT"

openssl verify -CAfile "$CA" "$CERT"

if [ -f "$CRL" ]; then
    echo "Verificando revocación con CRL: $CRL"
    openssl verify -CAfile "$CA" -crl_check -CRLfile "$CRL" "$CERT"
fi

Ejemplo de uso:

$ ./validar_cert.sh servidor.cert.pem ca.cert.pem crl.pem

→ Mostrará si el certificado es válido, y si ha sido revocado.

Revocación desde navegador

Cuando usas una CA propia, los navegadores no pueden consultar una CRL externa automáticamente, pero puedes hacerlo manualmente:

1. Incluir CRL en el certificado del servidor

Asegúrate de indicar la ubicación de la lista en el certificado:

# openssl ca -config openssl.cnf \
  -crl_distribution_points URI:http://ca.local/crl.pem

→ El navegador podrá consultar la URL si tiene acceso.

2. Asegurar que el servidor sirva la CRL

Ejemplo con Apache:

Alias /crl.pem /opt/ca/crl/ca.crl.pem

<Directory "/opt/ca/crl/">
    Options Indexes FollowSymLinks
    Require all granted
</Directory>

→ Así puede ser consultada desde http://ca.local/crl.pem

3. En navegadores internos

Instalar el certificado raíz (CA) como autoridad confiable en:

Firefox: Preferencias → Privacidad → Certificados → Importar
Chrome: Configuración del sistema operativo → Seguridad → Autoridades

→ Una vez cargado, el navegador podrá validar el certificado y consultar la CRL si está definida en el certificado.

Integrar la CA en una VPN interna (ej. OpenVPN)

OpenVPN permite usar certificados emitidos por tu propia CA para autenticar cliente y servidor.

1. Estructura recomendada

/etc/openvpn/
+---- ca.crt                  # Certificado raíz de tu CA
+---- server.crt              # Certificado firmado para el servidor VPN
+---- server.key              # Clave privada del servidor
+---- dh.pem                  # Parámetros Diffie-Hellman
+---- crl.pem                 # Lista de revocación
+---- client-configs/         # Archivos por cliente

2. Configuración del servidor `/etc/openvpn/server.conf`

port 1194
proto udp
dev tun

ca ca.crt
cert server.crt
key server.key
crl-verify crl.pem
dh dh.pem

auth SHA256
cipher AES-256-CBC

→ Al incluir crl-verify, OpenVPN bloqueará automáticamente certificados revocados.

3. Emisión de certificados para clientes

Usa el script de emisión ajustado:

/opt/ca/scripts/emitir.sh cliente01

→ Copia cliente01.key.pem y cliente01.cert.pem al dispositivo cliente.

4. Configuración del cliente

Archivo .ovpn:

client
dev tun
proto udp
remote vpn.luisgulo.local 1194

ca ca.crt
cert cliente01.cert.pem
key cliente01.key.pem

auth SHA256
cipher AES-256-CBC

→ Si el certificado es revocado y aparece en la CRL, la conexión será rechazada.

Automatización con Ansible

Ansible es una herramienta de automatización que permite ejecutar tareas en uno o varios servidores sin necesidad de instalar agentes. Utiliza SSH, inventarios de hosts y archivos YAML para definir configuraciones, despliegues o acciones recurrentes.

Es ideal para administración remota, automatización de tareas y la gestión de servidores de forma declarativa.

Está guía está preparada para entornos Debian, pero es perfectamente aplicable a otras distribuciones.

1. Instalación en Debian/Ubuntu

sudo apt update
sudo apt install ansible
ansible --version

→ Se instala en el nodo controlador (máquina local). No requiere nada en los servidores remotos.

2. Inventario de hosts

Archivo /etc/ansible/hosts o personalizado:

[web]
192.168.1.10
192.168.1.11

[db]
192.168.1.12

[all:vars]
ansible_user=admin
ansible_ssh_private_key_file=~/.ssh/id_rsa

→ También puedes usar inventarios dinámicos, JSON o scripts.

3. Comandos ad-hoc

Ejecutar tareas individuales sin playbook:

ansible all -m ping                         # Verifica conectividad
ansible web -m shell -a "df -h"             # Comando remoto
ansible db -m apt -a "name=htop state=present"   # Instalar paquete
ansible all -m copy -a "src=./archivo.txt dest=/tmp/"

→ Muy útil para intervención rápida sobre múltiples máquinas.

4. Crear un playbook básico

Archivo despliegue.yml:

- name: Configurar servidores web
  hosts: web
  become: true

  tasks:
    - name: Instalar Apache
      apt:
        name: apache2
        state: present

    - name: Copiar archivo index.html
      copy:
        src: ./index.html
        dest: /var/www/html/index.html

    - name: Asegurar que el servicio está activo
      service:
        name: apache2
        state: started
        enabled: true

Ejecutar el playbook:

ansible-playbook despliegue.yml

5. Variables y roles

Variables en group_vars/web.yml:

puerto_http: 80
documento: index.html

Uso en playbooks:

port: "{{ puerto_http }}"
src: "./{{ documento }}"

→ Roles permiten separar tareas, handlers, templates y defaults por estructura modular.

6. Automatizar backups, auditorías o tareas personalizadas

Ejemplo: Playbook auditoria.yml

- name: Auditar acceso SSH
  hosts: all
  become: true

  tasks:
    - name: Extraer últimos accesos
      shell: last
      register: resultado

    - name: Guardar en log local
      local_action:
        copy content="{{ resultado.stdout }}"
        dest="./logs/{{ inventory_hostname }}_access.log"

→ Puede ejecutarse por cron, desde un CI/CD, o integrarse con Git.

7. Recomendaciones

Usa --check para probar sin aplicar cambios
Documenta bien los roles y variables
Controla versiones con Git
Usa ansible-vault para proteger contraseñas y secretos

Manual Técnico: Administración y productividad en Linux (RSA-00) [Información]

hace 3 días • 2 min de lectura

La ruta del SysAdmin

Manual Técnico: Administración y productividad en Linux (RSA-00) [ePub + PDF]

hace 3 días • 1 min de lectura

La ruta del SysAdmin

Comandos Debian: Referencia Avanzada (RSA Ref.2)

hace 3 días • 2 min de lectura

Manual Técnico: Administración y productividad en Linux (RSA-00) [Información]

Manual Técnico: Administración y productividad en Linux (RSA-00) [ePub + PDF]

Comandos Debian: Referencia Avanzada (RSA Ref.2)

Comandos Debian: Referencia Básica (RSA Ref.1)

1. Servidor web: Apache

Instalación y activación

Configuración básica

2. Servidor web: Nginx

Instalación y activación

Configuración básica

3. Servidor FTP con vsftpd

Instalación y activación

Configuración básica

4. Compartición de archivos con Samba

Instalación

Definir recursos en /etc/samba/smb.conf

Crear usuario Samba

5. Configuración de DNS local con BIND

Instalación

Archivo de zona en /etc/bind/db.local

Activar servicio

6. Acceso remoto con SSH

Instalación y activación

Claves públicas

Configuración segura

7. Escritorio remoto con VNC (ejemplo con TigerVNC)

8. Servidor de correo simple con Postfix

Instalación

Enviar correo desde terminal

Configuración de certificados SSL

1. Generar certificado autofirmado con OpenSSL

2. Configurar Apache con SSL

3. Configurar Nginx con SSL

4. Obtener certificado gratuito con Let's Encrypt (Certbot)

5. Seguridad adicional en SSL/TLS

Firma de certificados con una CA propia y automatización de emisión

1. Crear tu propia CA

2. Generar certificado para un servidor

3. Instalar certificado en Apache o Nginx

4. Automatizar emisión y renovación

5. Programar renovación automática

Recomendaciones

Autoridad Certificadora (CA) interna: estructura completa y scripts

1. Estructura de directorios de la CA

2. Archivo de configuración openssl.cnf

3. Crear clave y certificado raíz

4. Script para emitir certificados (scripts/emitir.sh)

5. Script para revocar certificados (scripts/revocar.sh)

6. Verificar expiración de un certificado

7. Script de renovación automática (scripts/renovar.sh)

8. Configuración recomendada

Validación completa de la cadena desde cliente

Script validar_cert.sh

Revocación desde navegador

1. Incluir CRL en el certificado del servidor

2. Asegurar que el servidor sirva la CRL

3. En navegadores internos

Integrar la CA en una VPN interna (ej. OpenVPN)

1. Estructura recomendada

2. Configuración del servidor /etc/openvpn/server.conf

3. Emisión de certificados para clientes

4. Configuración del cliente

Automatización con Ansible

1. Instalación en Debian/Ubuntu

2. Inventario de hosts

3. Comandos ad-hoc

4. Crear un playbook básico

5. Variables y roles

6. Automatizar backups, auditorías o tareas personalizadas

7. Recomendaciones

Etiquetas

Suscríbete a nuestro Newsletter

Luis GuLo

Recomendado para ti

Manual Técnico: Administración y productividad en Linux (RSA-00) [Información]

Manual Técnico: Administración y productividad en Linux (RSA-00) [ePub + PDF]

Comandos Debian: Referencia Avanzada (RSA Ref.2)

Definir recursos en `/etc/samba/smb.conf`

Archivo de zona en `/etc/bind/db.local`

2. Archivo de configuración `openssl.cnf`

4. Script para emitir certificados (`scripts/emitir.sh`)

5. Script para revocar certificados (`scripts/revocar.sh`)

7. Script de renovación automática (`scripts/renovar.sh`)

Script `validar_cert.sh`

2. Configuración del servidor `/etc/openvpn/server.conf`