# VPS Linux: comandos esenciales para empezar

**URL:** <https://forum.boxtoplay.com/t/vps-linux-comandos-esenciales-para-empezar/31846>\
**Category:** VPS\
**Tags:** español, vps\
**Created:** [Août 6, 2026, 4:22 UTC](https://forum.boxtoplay.com/t/vps-linux-comandos-esenciales-para-empezar/31846 "2026-08-06T16:22:46Z")\
**Posts on this page:** 1\
**Page:** 1

<div class="post-metadata">

**Author:** ![BoxToPlay-helper](https://forum.boxtoplay.com/user_avatar/forum.boxtoplay.com/boxtoplay-helper/32/5468_2.png) [@BoxToPlay-helper](https://forum.boxtoplay.com/u/BoxToPlay-helper)\
**Post date:** [Août 6, 2026, 4:22 UTC](https://forum.boxtoplay.com/t/vps-linux-comandos-esenciales-para-empezar/31846/1 "2026-08-06T16:22:46Z")

</div>

![VPS Linux: comandos esenciales para empezar](https://forum.boxtoplay.com/uploads/default/original/2X/8/8eb6ca137492867e1d9daf74848f2ae74419efda.jpeg)

## VPS Linux: comandos esenciales para empezar

Acabas de recibir un VPS Linux de BoxToPlay y una dirección IP pública, pero nunca has utilizado Linux. ¿Dónde se escriben los comandos? ¿Cómo se crea una carpeta, se edita un archivo de configuración, se sube un archivo desde Windows, se instala una herramienta o se mantiene una aplicación activa después de cerrar el terminal?

Esta guía de BoxToPlay empieza desde cero. Su objetivo no es enseñar todo Linux, sino proporcionar las bases prácticas necesarias para alojar un sitio web, un bot, un servicio de juego, una API, una base de datos u otra aplicación en un VPS Debian o Ubuntu.

Cada comando se explica antes de pasar a la siguiente tarea. Cuando existe un equivalente útil en Windows, una **referencia de Windows** relaciona el concepto nuevo con algo que ya conoces.

> **Importante:** los ejemplos utilizan la dirección reservada para documentación `203.0.113.10`, la cuenta `root` y la carpeta `/opt/mi-servicio`. Sustitúyelos por tus propios valores. Nunca pegues un comando desconocido con permisos de administrador sin entenderlo.

Los bloques marcados como `bash` se escriben en el terminal SSH del VPS, es decir, dentro de PuTTY, Termix u otro cliente SSH ya conectado. Los bloques marcados como `powershell` se escriben en tu PC Windows.

Si empiezas desde cero, sigue este orden:

1. Abrir una conexión SSH desde Windows.
2. Comprobar la cuenta conectada y la versión de Linux.
3. Actualizar el sistema.
4. Entender `root`, `sudo` y la creación opcional de usuarios.
5. Aprender a navegar, copiar y editar archivos.
6. Instalar herramientas útiles.
7. Ejecutar tu aplicación como servicio y comprobar logs, firewall y copias de seguridad.

## ¿Qué cambia entre un PC Windows y un VPS Linux?

Windows suele administrarse mediante ventanas, menús, el Explorador de archivos, el Administrador de tareas e instaladores gráficos. Un servidor Linux se administra normalmente a distancia mediante un terminal. La presentación cambia, pero casi todos los conceptos tienen un equivalente.

| Acción conocida en Windows | Equivalente habitual en un servidor Linux |
| --- | --- |
| Windows Terminal o PowerShell | Terminal local desde el que se inicia una conexión SSH |
| Escritorio remoto | SSH, una conexión segura en modo texto |
| Explorador de archivos | `ls`, `cd`, `cp`, `mv`, `rm` o un cliente SFTP como WinSCP |
| Bloc de notas | `nano` en el terminal |
| Windows Update | `apt update` seguido de `apt upgrade` |
| WinGet o un instalador | `apt install nombre-del-paquete` |
| Ejecutar como administrador y UAC | `sudo` |
| Administrador de tareas | `htop`, `ps`, `free` y `df` |
| Servicios de Windows | `systemd` y `systemctl` |
| Visor de eventos | `journalctl` |
| Firewall de Windows Defender | `ufw`, `nftables` o `iptables` |
| 7-Zip o Extraer todo | `unzip`, `tar`, `gzip` y `xz` |
| Copia de archivos por red | SFTP, SCP o `rsync` |

Linux distingue normalmente entre mayúsculas y minúsculas. `Config`, `config` y `CONFIG` pueden ser tres nombres diferentes.

## Elegir las herramientas en Windows

Solo necesitas unos pocos programas para empezar. Lo importante es tener dos capacidades: abrir el terminal SSH del VPS y transferir archivos por SFTP. Termix reúne ambos usos en una sola aplicación. PuTTY con WinSCP sigue siendo el dúo clásico si prefieres separar terminal y gestión de archivos.

### PuTTY: el cliente SSH gráfico clásico

[PuTTY](https://www.chiark.greenend.org.uk/~sgtatham/putty/latest.html) ofrece una ventana de conexión, sesiones guardadas y herramientas complementarias como PuTTYgen para las claves SSH y PSCP para transferir archivos.

Resulta útil si prefieres una aplicación dedicada. No instales varios clientes SSH solo porque aparecen en esta guía: elige el que entiendas mejor.

### WinSCP: una vista parecida al Explorador

[WinSCP](https://winscp.net/eng/download.php) muestra los archivos locales de Windows a un lado y los del VPS al otro. Utiliza SFTP a través de la misma conexión segura que SSH.

WinSCP facilita las transferencias si has elegido PuTTY para el terminal y quieres una herramienta separada para subir archivos, descargar copias o editar un fichero pequeño.

### Termix: SSH y archivos en una sola interfaz

[Termix](https://github.com/Termix-SSH/Termix) reúne acceso SSH, gestión remota de archivos compatible con SFTP, túneles, estadísticas y organización de servidores.

Termix pasa a ser la recomendación más sencilla si quieres hacerlo todo en el mismo sitio: abrir el terminal, transferir archivos y guardar tus conexiones. PuTTY con WinSCP sigue siendo una alternativa clásica si prefieres dos herramientas separadas, conocidas y ligeras.

## Antes de empezar: cómo leer un comando Linux

Un comando suele contener tres tipos de elementos:

```plaintext
comando opción argumento

```

- El **comando** es el programa que se ejecuta, por ejemplo `ls`.
- Una **opción** modifica su comportamiento. Suele empezar por `-` o `--`, como `-h` o `--help`.
- Un **argumento** indica el elemento sobre el que debe trabajar, por ejemplo `/opt/mi-servicio`.

Observa este ejemplo:

```bash
ls -lah /opt

```

- `ls` muestra archivos y carpetas.
- `-l` solicita una lista detallada.
- `-a` incluye los elementos ocultos cuyo nombre empieza por un punto.
- `-h` muestra los tamaños en unidades legibles como KB, MB o GB.
- `/opt` es la carpeta que se inspecciona.

También encontrarás estos símbolos:

- `~` representa la carpeta personal del usuario actual, por ejemplo `/root`.
- `.` representa la carpeta actual.
- `..` representa la carpeta superior.
- `/` es la raíz de todo el sistema de archivos Linux, no una letra de unidad.
- `$USER` es una variable que contiene el nombre de la cuenta actual.
- `*` es un comodín que puede representar varios nombres.
- `|` envía el resultado de un comando al comando siguiente.
- `Ctrl+C` interrumpe un comando que se está ejecutando.

> **Referencia de Windows:** un comando de PowerShell como `Get-ChildItem -Force C:\Temp` sigue la misma idea general: comando, opción y destino.

Para abrir el manual integrado de un comando:

```bash
man ls

```

- `man` abre una página del manual.
- `ls` es el comando que quieres consultar.
- Utiliza las flechas para desplazarte, `/` para buscar y `q` para salir.

Una ayuda más corta suele estar disponible así:

```bash
ls --help

```

- `--help` pide a `ls` que muestre sus opciones sin abrir el manual completo.

## Conectarse al VPS con tu cliente SSH

Después de la entrega de un VPS BoxToPlay, el panel de cliente suele mostrar:

- la dirección IP pública.
- el puerto SSH, normalmente `22`.
- el usuario SSH inicial `root`.
- una contraseña o una clave SSH privada.

Abre el cliente SSH elegido, por ejemplo PuTTY o Termix, y crea una nueva conexión. Rellena:

- Host o dirección: `203.0.113.10`.
- Puerto: `22` o el puerto SSH indicado en tu panel BoxToPlay.
- Protocolo: `SSH`.
- Usuario: `root`.
- Autenticación: la contraseña inicial o la clave privada.

La cuenta `root` es el superadministrador de Linux. En un VPS BoxToPlay, es la cuenta normal de primera administración. Puede modificar todo el sistema, así que conviene leer los comandos antes de pegarlos.

En PuTTY, escribe la dirección en `Host Name`, comprueba el `Port`, mantén el tipo de conexión en `SSH` y guarda la sesión si quieres reutilizarla más tarde.

En Termix, crea un servidor o una conexión e introduce el host, el puerto, el usuario y el método de autenticación.

En WinSCP, elige `SFTP`, introduce los mismos datos y conéctate para gestionar archivos. WinSCP no sustituye a un terminal completo: mantén PuTTY o Termix disponible para los comandos de administración.

La primera conexión muestra la huella digital del servidor. Compárala con la que muestre BoxToPlay cuando esté disponible y acéptala solo si el destino es correcto. Esta huella ayuda a detectar una suplantación del servidor.

Cuando se solicita una contraseña, no aparece ningún carácter mientras escribes. Es normal: Linux no muestra puntos ni asteriscos para las contraseñas del terminal.

> **Referencia de Windows:** SSH cumple una función parecida al Escritorio remoto, pero abre una sesión de texto en lugar de un escritorio gráfico.

## Identificar el sistema antes de modificarlo

Una vez conectado, ejecuta:

```bash
whoami
hostname
cat /etc/os-release
uname -r

```

- `whoami` muestra el nombre de la cuenta conectada. Este comando también existe en Windows.
- `hostname` muestra el nombre de la máquina. También existe en Windows.
- `cat` muestra un archivo de texto. `/etc/os-release` describe la distribución Linux y su versión.
- `uname -r` muestra la versión del núcleo Linux. El núcleo es la parte central del sistema operativo.

En un VPS Ubuntu 24.04 recién instalado, la salida era parecida a esta:

```plaintext
root
vps-demo
PRETTY_NAME="Ubuntu 24.04.4 LTS"
6.8.0-136-generic

```

La primera línea confirma la cuenta utilizada. La segunda muestra el nombre de la máquina. Las dos últimas identifican la distribución Linux y el núcleo.

> **Referencia de Windows:** `cat /etc/os-release` y `uname -r` ofrecen información similar a `Get-ComputerInfo` en PowerShell o a la ventana `winver`.

## Entender `sudo`, `apt` y `apt-get`

Debian y Ubuntu distribuyen el software en forma de **paquetes**. Un paquete contiene un programa, su versión y la información necesaria para instalarlo. Los paquetes se descargan desde **repositorios** , es decir, catálogos de software configurados en el servidor.

`apt` es el gestor de paquetes pensado para el uso interactivo en un terminal. Permite buscar, instalar, actualizar y eliminar software.

También verás `apt-get`, con un guion. Ambos utilizan los mismos repositorios e instalan los mismos paquetes:

- `apt` presenta una salida más clara para una persona.
- `apt-get` mantiene un comportamiento estable que suele preferirse en scripts automatizados.

| Con `apt` | Sintaxis antigua habitual con `apt-get` | Resultado |
| --- | --- | --- |
| `apt update` | `apt-get update` | Actualizar el catálogo de paquetes |
| `apt install htop` | `apt-get install htop` | Instalar el paquete `htop` |

Esta guía utiliza `apt`. No hace falta repetir la misma acción con `apt-get`.

`sudo` significa «ejecutar el comando siguiente con permisos de administrador». Es comparable a Ejecutar como administrador y a la confirmación UAC de Windows.

> **Referencia de Windows:** `apt` combina conceptos de Windows Update y WinGet. Los repositorios Linux proporcionan tanto actualizaciones del sistema como muchas aplicaciones.

Algunas instalaciones mínimas de Debian todavía no incluyen `sudo`. Este caso solo se aplica si ya estás conectado como `root`. Si el terminal muestra `sudo: command not found`, ejecuta:

```bash
apt update
apt install sudo

```

- `apt update` actualiza el catálogo sin `sudo` porque `root` ya tiene permisos de administrador.
- `apt install sudo` descarga e instala el paquete que proporciona el comando `sudo`.

No ejecutes estas líneas desde una cuenta normal sin permisos de administrador: Linux las rechazará.

## Instalar las primeras actualizaciones con seguridad

Si `whoami` ha mostrado `root`, ya tienes permisos de administrador y puedes quitar `sudo` de los comandos de esta sección. Con una cuenta de administración normal, mantenlo.

Primero actualiza el catálogo de software:

```bash
sudo apt update

```

- `sudo` solicita permisos de administrador.
- `apt` abre el gestor de paquetes.
- `update` descarga la lista actual de paquetes y versiones.

Este comando todavía no actualiza ningún programa instalado. Solo busca las versiones disponibles, como la primera fase de Windows Update.

Ahora revisa e instala las actualizaciones:

```bash
sudo apt upgrade

```

- `upgrade` compara los paquetes instalados con el catálogo actualizado.
- Antes de modificar nada aparece un resumen.
- Escribe `Y` y pulsa Entrar si los cambios propuestos son correctos.

Más adelante puedes encontrar esta variante:

```bash
sudo apt upgrade -y

```

- `-y` responde afirmativamente de forma automática a las confirmaciones.
- Es útil para una operación conocida, pero impide revisar el resumen antes de continuar.

Para tu primera actualización, utiliza la versión sin `-y`.

> **Referencia de Windows:** `apt update` busca actualizaciones. `apt upgrade` las descarga y las instala.

## Configurar la zona horaria y comprobar la sincronización

Una hora correcta es imprescindible para entender los logs, ejecutar tareas programadas en el momento previsto y validar certificados HTTPS. Empieza mostrando la configuración actual:

```bash
timedatectl status

```

- `timedatectl` consulta y configura el reloj del sistema.
- `status` muestra la hora local, la hora universal UTC, la zona horaria y el estado de la sincronización de red.
- No se necesita `sudo` porque este comando no modifica nada.

Ejemplo de salida en un VPS Ubuntu 24.04 recién instalado:

```plaintext
Local time: Sun 2026-08-02 00:59:56 UTC
Universal time: Sun 2026-08-02 00:59:56 UTC
Time zone: Etc/UTC (UTC, +0000)
System clock synchronized: yes
NTP service: active

```

La salida suele aparecer en inglés. Aquí, `System clock synchronized: yes` indica que el reloj está sincronizado, y `NTP service: active` indica que la sincronización horaria por red funciona. Según la versión de Debian o Ubuntu, la sincronización puede estar gestionada por `chrony` o `systemd-timesyncd`. No instales un segundo servicio de sincronización horaria sin identificar primero el que ya funciona.

Muestra las zonas disponibles si no conoces el identificador exacto:

```bash
timedatectl list-timezones

```

- `list-timezones` muestra identificadores reconocidos como `Europe/Madrid`.
- Utiliza las flechas para recorrer la lista y pulsa `q` para salir si se abre en un visor.

Configura la zona horaria de tu región:

```bash
sudo timedatectl set-timezone Europe/Madrid

```

- `sudo` autoriza la modificación de un ajuste del sistema.
- `set-timezone` cambia la zona utilizada para mostrar las fechas.
- `Europe/Madrid` es el identificador del ejemplo, que debes sustituir si trabajas en otra región.

Ejecuta de nuevo `timedatectl status` para comprobar el resultado.

> **Referencia de Windows:** estos comandos corresponden a los ajustes Fecha y hora de Windows. La zona horaria controla cómo se muestran las fechas y la sincronización NTP equivale a la opción «Establecer hora automáticamente».

## Comprobar las actualizaciones automáticas de seguridad

Las comprobaciones manuales con `apt update` y `apt upgrade` siguen siendo útiles, pero un servidor conectado permanentemente también debe recibir correcciones de seguridad con regularidad. Ubuntu suele instalar el paquete `unattended-upgrades` de forma predeterminada. Una imagen Debian o mínima puede no incluirlo o no tenerlo activado.

Comprueba primero si el paquete está instalado:

```bash
apt policy unattended-upgrades

```

- `apt policy` muestra la versión instalada y la disponible de un paquete.
- `unattended-upgrades` es el paquete que puede instalar automáticamente las actualizaciones autorizadas.
- `Installed: (none)` significa que el paquete no está instalado.

Comprueba después las planificaciones de APT conocidas por systemd:

```bash
systemctl list-timers apt-daily.timer apt-daily-upgrade.timer --no-pager

```

- `systemctl list-timers` muestra las tareas que se ejecutan según una planificación.
- `apt-daily.timer` actualiza periódicamente la información de los paquetes.
- `apt-daily-upgrade.timer` inicia el tratamiento de las actualizaciones automáticas.
- `--no-pager` muestra el resultado directamente en el terminal.

Si falta el paquete y quieres utilizar este mecanismo en Debian o Ubuntu:

```bash
sudo apt install unattended-upgrades
sudo dpkg-reconfigure unattended-upgrades

```

- `apt install unattended-upgrades` instala el mecanismo de actualización automática.
- `dpkg-reconfigure` vuelve a abrir el asistente de configuración del paquete instalado.
- Responde sí cuando pregunte si deseas activar las actualizaciones automáticas de seguridad.

Este mecanismo no actualiza automáticamente todas las aplicaciones descargadas manualmente ni todos los repositorios de terceros. Sigue vigilando tu servicio, sus copias de seguridad y sus propios avisos de seguridad.

Algunas actualizaciones del kernel o de componentes centrales requieren reiniciar. No reinicies en mitad de una operación. Comprueba las copias de seguridad, planifica la interrupción y, solo cuando se solicite reiniciar, utiliza:

```bash
sudo reboot

```

- `sudo` solicita permisos de administrador.
- `reboot` detiene los servicios y reinicia el VPS.
- La conexión SSH se cierra inmediatamente y debe volver a estar disponible después del arranque.

> **Referencia de Windows:** `unattended-upgrades` se parece a la instalación automática de correcciones de seguridad mediante Windows Update. `sudo reboot` corresponde a Reiniciar, no a Apagar.

## Crear un usuario Linux (opcional)

En un VPS BoxToPlay, la administración se realiza generalmente con la cuenta `root`. Crear otro usuario no es un paso obligatorio para empezar. Es útil si quieres separar un acceso, crear una cuenta para otra persona o ver un ejemplo sencillo de usuarios Linux.

Crea un usuario normal:

```bash
sudo adduser usuario
id usuario

```

- `sudo adduser usuario` crea el usuario, solicita su contraseña y prepara `/home/usuario` con privilegios de administrador.
- `id usuario` muestra sus identificadores y grupos.

Por defecto, este usuario no es administrador. Si quieres permitirle ejecutar comandos con `sudo`, añádelo explícitamente al grupo `sudo`:

```bash
sudo usermod -aG sudo usuario
id usuario

```

- `sudo usermod` modifica un usuario existente con privilegios de administrador.
- `-a` significa añadir sin retirar los grupos que ya tiene.
- `-G sudo` añade el usuario al grupo llamado `sudo`.

> **Referencia de Windows:** crear solo el usuario se parece a crear una cuenta local estándar. Añadirlo al grupo `sudo` le permite elevar comandos concretos, como una cuenta Windows añadida al grupo Administradores.

Si pruebas esta cuenta nueva, mantén abierta la sesión `root`, abre una segunda conexión como `usuario` y ejecuta:

```bash
sudo whoami

```

- `sudo` solicita la elevación y puede pedir la contraseña de `usuario`.
- `whoami` muestra la identidad utilizada para el comando.
- El resultado esperado es `root`.

No cierres la sesión `root` mientras cambias la configuración SSH o el firewall. Es tu vía de recuperación si una conexión nueva falla.

## Sustituir la contraseña por una clave SSH

Una clave SSH utiliza dos archivos:

- la **clave privada** permanece en tu ordenador Windows y nunca debe compartirse.
- la **clave pública** se copia al VPS y permite reconocer tu ordenador.

Genera una clave en Windows:

```powershell
ssh-keygen -t ed25519 -a 100

```

- `ssh-keygen` crea y administra claves SSH.
- `-t ed25519` selecciona el tipo moderno Ed25519.
- `-a 100` aumenta el trabajo necesario para probar cada contraseña si alguien roba la clave privada.
- Pulsa Entrar para aceptar la ubicación propuesta y elige una frase de contraseña sólida.

Copia la clave pública a la cuenta `root`:

```powershell
Get-Content $env:USERPROFILE\.ssh\id_ed25519.pub | ssh root@203.0.113.10 "umask 077; mkdir -p ~/.ssh; cat >> ~/.ssh/authorized_keys; chmod 700 ~/.ssh; chmod 600 ~/.ssh/authorized_keys"

```

- `Get-Content` lee el archivo de clave pública en Windows.
- `$env:USERPROFILE` representa tu carpeta de perfil de Windows.
- `|` envía la clave pública al comando `ssh`.
- `umask 077` hace que los archivos nuevos sean privados para la cuenta remota.
- `mkdir -p ~/.ssh` crea la carpeta `.ssh` si no existe.
- `cat >> ~/.ssh/authorized_keys` añade la clave sin borrar las autorizadas anteriormente.

Termix y el cliente OpenSSH de Windows pueden usar directamente la clave privada creada con `ssh-keygen`. Para PuTTY, abre PuTTYgen, selecciona `Conversions > Import key`, elige la clave privada OpenSSH y guárdala como archivo `.ppk`. WinSCP también puede usar ese archivo `.ppk` para autenticarse.

Crea otra conexión `root` en Termix con la clave OpenSSH, o en PuTTY con el archivo `.ppk` creado por PuTTYgen. El cliente puede pedir la frase de paso de la clave, pero ya no debería pedir la contraseña de la cuenta Linux.

Solo después de que esta prueba funcione deberías plantearte cambiar la autenticación SSH o desactivar el inicio de sesión con contraseña. Conserva siempre la consola de rescate BoxToPlay o un método de recuperación antes de cambiar la configuración SSH.

Puedes seguir administrando el VPS como `root`. Si has creado un usuario adicional, configura su clave SSH por separado en el archivo `~/.ssh/authorized_keys` de esa cuenta.

> **Referencia de Windows:** la clave privada se parece a una credencial personal guardada en el equipo, mientras que la clave pública es una identidad autorizada en el servidor.

## Navegar por las carpetas

Muestra la ubicación actual:

```bash
pwd

```

- `pwd` significa print working directory.
- Muestra la ruta completa de la carpeta en la que trabajan los comandos.

Muestra su contenido:

```bash
ls -lah

```

- `ls` enumera los elementos.
- `-l` añade permisos, propietario, tamaño y fecha.
- `-a` incluye los elementos ocultos.
- `-h` utiliza tamaños legibles.

Entra en otra carpeta:

```bash
cd /opt

```

- `cd` significa change directory.
- `/opt` se utiliza a menudo para aplicaciones instaladas manualmente.

Vuelve a tu carpeta personal:

```bash
cd ~

```

- `~` se sustituye por la carpeta personal del usuario actual.

Sube a la carpeta superior:

```bash
cd ..

```

- `..` representa un nivel por encima de la carpeta actual.

> **Referencia de Windows:** `pwd`, `ls` y `cd` se parecen a `Get-Location`, `Get-ChildItem` y `Set-Location` en PowerShell. Windows utiliza letras de unidad y barras invertidas; Linux parte de `/` y utiliza barras normales.

## Crear, copiar, mover y eliminar archivos

Crea una carpeta para el servicio y entra en ella:

```bash
sudo mkdir -p /opt/mi-servicio
sudo chown "$USER":"$(id -gn)" /opt/mi-servicio
cd /opt/mi-servicio

```

- `mkdir` crea una carpeta.
- `-p` también crea las carpetas superiores que falten y no falla si ya existe.
- `chown` cambia el propietario.
- `"$USER":"$(id -gn)"` asigna el usuario actual y su grupo principal.
- `cd` entra en la carpeta.

Crea un archivo vacío:

```bash
touch configuracion.txt

```

- `touch` crea el archivo si no existe.
- Si ya existe, actualiza su fecha sin cambiar su contenido.

Copia el archivo:

```bash
cp configuracion.txt configuracion.backup.txt

```

- `cp` copia la primera ruta en la segunda.
- El archivo original permanece en su sitio.

Renombra o mueve la copia:

```bash
mv configuracion.backup.txt configuracion-antigua.txt

```

- `mv` mueve un elemento.
- Si ambas rutas están en la misma carpeta, el resultado visible es un cambio de nombre.

Elimina el archivo renombrado:

```bash
rm configuracion-antigua.txt

```

- `rm` elimina el archivo inmediatamente.
- Una sesión de terminal normal no dispone de Papelera de reciclaje.

Elimina una carpeta completa únicamente después de comprobar la ruta exacta:

```bash
rm -r carpeta-que-se-eliminara

```

- `-r` significa recursivo y permite entrar en la carpeta.
- Puede eliminar muchos archivos, por lo que debes inspeccionarla con `ls` primero.
- Nunca ejecutes un comando destructivo sin sustituir y comprobar la ruta de ejemplo.

> **Referencia de Windows:** `mkdir`, `cp`, `mv` y `rm` corresponden a Nueva carpeta, Copiar, Cortar o Cambiar nombre y Eliminar. La diferencia principal es que la eliminación desde el terminal suele ser inmediata.

## Editar un archivo de texto con Nano

Instala Nano si falta:

```bash
sudo apt install nano

```

- `sudo` solicita permisos de administrador.
- `apt install` descarga e instala un paquete.
- `nano` es el nombre del paquete y del comando que quedará disponible.

Abre un archivo:

```bash
nano /opt/mi-servicio/configuracion.txt

```

- `nano` inicia el editor.
- La ruta identifica el archivo que se abre o se crea.

Dentro de Nano:

- escribe normalmente para editar.
- pulsa `Ctrl+O` y después Entrar para guardar.
- pulsa `Ctrl+X` para salir.
- pulsa `Ctrl+W` para buscar.
- el símbolo `^` que muestra Nano representa la tecla Ctrl.

> **Referencia de Windows:** Nano desempeña el papel de un Bloc de notas sencillo dentro del terminal.

Para editar un archivo del sistema, añade `sudo`:

```bash
sudo nano /etc/hosts

```

- `sudo` es necesario porque `/etc/hosts` pertenece al sistema.
- `/etc` contiene numerosos archivos de configuración.

Crea una copia antes de modificar un archivo importante:

```bash
sudo cp /etc/hosts /etc/hosts.backup

```

- `cp` duplica el archivo original.
- El sufijo `.backup` es solo una convención de nombre fácil de reconocer.

## Subir archivos y comprimidos desde Windows

### SFTP con WinSCP

Crea una conexión WinSCP con:

- protocolo: SFTP.
- host: la IP del VPS.
- puerto: el puerto SSH.
- usuario: `root`.
- autenticación: contraseña o clave privada.

Sube primero los archivos a `/root/uploads`. Así quedan en la carpeta personal de `root` antes de moverlos a la ruta final de la aplicación.

Prepara el destino en el VPS:

```bash
mkdir -p ~/uploads
ls -ld ~/uploads

```

- `mkdir -p` crea la carpeta `uploads` dentro de tu carpeta personal.
- `ls -ld` muestra la propia carpeta, con su propietario y permisos.

### SCP desde PowerShell

Sube un archivo ZIP:

```powershell
scp "$env:USERPROFILE\Downloads\aplicacion.zip" root@203.0.113.10:/root/uploads/

```

- `scp` copia archivos de forma segura a través de SSH.
- La ruta de Windows es el origen local.
- `root@203.0.113.10:` identifica la cuenta y el servidor remotos.
- `/root/uploads/` es el destino.

Con un puerto SSH personalizado:

```powershell
scp -P 2222 "$env:USERPROFILE\Downloads\aplicacion.zip" root@203.0.113.10:/root/uploads/

```

- SCP utiliza `-P` mayúscula para el puerto.
- SSH utiliza en cambio `-p` minúscula.

Descarga un archivo desde el VPS:

```powershell
scp root@203.0.113.10:/var/log/mi-servicio/app.log "$env:USERPROFILE\Downloads\"

```

- La ruta remota aparece primero porque es el origen.
- La carpeta Descargas de Windows aparece después porque es el destino.

## Inspeccionar y extraer archivos comprimidos

Instala las herramientas habituales:

```bash
sudo apt install unzip zip p7zip-full xz-utils

```

- `apt install` puede instalar varios paquetes separados por espacios.
- `unzip` extrae archivos `.zip`.
- `zip` crea archivos `.zip`.
- `p7zip-full` añade compatibilidad con formatos de 7-Zip.
- `xz-utils` gestiona la compresión `.xz`.

Inspecciona un ZIP antes de extraerlo:

```bash
unzip -l ~/uploads/aplicacion.zip

```

- `unzip` trabaja con el archivo ZIP.
- `-l` enumera su contenido sin extraerlo.
- Revisar los nombres ayuda a detectar una estructura inesperada o rutas sospechosas.

Crea un destino aislado en tu carpeta personal y extrae primero el ZIP allí:

```bash
mkdir -p ~/imports
unzip ~/uploads/aplicacion.zip -d ~/imports
ls -la ~/imports/mi-servicio

```

- `mkdir -p` prepara una carpeta temporal dedicada.
- `unzip` lee el archivo subido.
- `-d` selecciona la carpeta de extracción.
- `ls -la` permite revisar los archivos extraídos antes de moverlos a la carpeta final de la aplicación.

Enumera un archivo `.tar.gz`:

```bash
tar -tzf ~/uploads/archivo.tar.gz

```

- `tar` gestiona archivos tar.
- `-t` enumera su contenido.
- `-z` utiliza compresión gzip.
- `-f` indica que el argumento siguiente es el archivo.

Ejemplo de salida para un archivo sencillo:

```plaintext
mi-servicio/
mi-servicio/config/
mi-servicio/config/config.yml

```

Si ves rutas absolutas como `/etc/...`, rutas con `../` o archivos inesperados, detente antes de extraer y verifica el origen del archivo.

Extráelo en la misma carpeta aislada:

```bash
mkdir -p ~/imports
tar -xzf ~/uploads/archivo.tar.gz -C ~/imports
ls -la ~/imports/mi-servicio

```

- `-x` extrae.
- `-z` descomprime gzip.
- `-f` selecciona el archivo.
- `-C` cambia a la carpeta de destino antes de extraer.
- `mkdir -p` se repite aquí para que el ejemplo tar funcione aunque no hayas extraído antes un ZIP.
- Adapta `~/imports/mi-servicio` si el archivo contiene otra carpeta raíz.

Después de revisar la carpeta extraída, copia su contenido a la ruta final del servicio:

```bash
sudo mkdir -p /opt/mi-servicio/releases/nueva
sudo rsync -a ~/imports/mi-servicio/ /opt/mi-servicio/releases/nueva/

```

- `sudo mkdir -p` crea la carpeta final del sistema si hace falta.
- `rsync -a` copia el contenido extraído conservando los metadatos habituales.

> **Referencia de Windows:** estos comandos realizan el mismo trabajo que Extraer todo o 7-Zip. En un servidor es especialmente importante enumerar primero el contenido de un archivo procedente del exterior.

## Instalar una caja de herramientas práctica

Instala un pequeño conjunto de herramientas útiles:

```bash
sudo apt install curl wget git htop tree jq rsync ca-certificates

```

Cada paquete tiene una función diferente:

- `curl` envía peticiones web y permite probar un endpoint HTTP.
- `wget` descarga un archivo desde una URL.
- `git` descarga y actualiza repositorios de código.
- `htop` muestra procesos, CPU y memoria.
- `tree` muestra las carpetas como un árbol.
- `jq` lee y filtra JSON.
- `rsync` sincroniza archivos de forma eficiente.
- `ca-certificates` proporciona las autoridades de certificación de confianza para HTTPS.

> **Referencia de Windows:** WinGet instala aplicaciones en Windows. En Debian y Ubuntu, `apt` instala estas herramientas y sus dependencias desde los repositorios configurados.

No instales un comando solo porque aparece en una guía. Comprueba primero su documentación oficial, su procedencia y su finalidad.

## Entender las carpetas útiles para el alojamiento

Empieza explorando sin modificar archivos:

```bash
pwd
ls -lah
cd /opt
ls -lah
cd ~

```

- `pwd` significa «&nbsp;print working directory&nbsp;» y muestra la ruta de la carpeta actual. El equivalente de PowerShell es `Get-Location`.
- `ls -lah` muestra el contenido detallado, incluidos los elementos ocultos, con tamaños legibles. El equivalente de PowerShell es `Get-ChildItem -Force`.
- `cd /opt` mueve el terminal a `/opt`. El equivalente de PowerShell es `Set-Location`.
- El segundo `ls -lah` muestra el contenido de `/opt`.
- `cd ~` vuelve a tu carpeta personal.

Las ubicaciones principales son:

- `/root`: carpeta personal de la cuenta `root`, similar a `C:\Users\Administrador`.
- `/home/usuario`: carpeta personal de un usuario creado con `adduser`, similar a `C:\Users\Usuario`.
- `/opt/mi-servicio`: ubicación habitual para una aplicación autónoma, similar a `C:\Program Files\MiServicio`.
- `/etc/mi-servicio`: configuración del sistema, sin equivalente único en Windows.
- `/var/lib/mi-servicio`: datos persistentes de una aplicación, similar a `C:\ProgramData\MiServicio`.
- `/var/log`: muchos logs del sistema y de las aplicaciones, similar al Visor de eventos y a las carpetas de logs de Windows.
- `/var/www`: archivos de un servidor web clásico, similar a `C:\inetpub\wwwroot` con IIS.
- `/tmp`: archivos temporales, similar a `%TEMP%`.

Una ruta que empieza por `/` es absoluta: parte de la raíz del sistema. Una ruta sin `/` inicial es relativa a la carpeta mostrada por `pwd`.

## Entender usuarios, grupos y permisos

Linux no concede los mismos derechos a todas las cuentas. Cada archivo y cada carpeta tiene un propietario, un grupo y permisos separados para el propietario, el grupo y los demás usuarios. Esto impide que un servicio, un script o un usuario local lea o modifique archivos que no le corresponden.

Inspecciona una carpeta y un archivo:

```bash
ls -ld /opt/mi-servicio
ls -l /opt/mi-servicio/config/config.yml

```

Ejemplo de salida:

```plaintext
drwxr-x--- 3 miservicio miservicio 4096 Aug 2 02:34 /opt/mi-servicio
-rw-r----- 1 miservicio miservicio 17 Aug 2 02:34 /opt/mi-servicio/config/config.yml

```

El inicio de cada línea muestra el tipo y los permisos:

- `d` indica una carpeta, `-` indica un archivo normal.
- `r` significa lectura.
- `w` significa escritura.
- `x` significa ejecución para un archivo, o entrada/travesía para una carpeta.
- Los tres primeros permisos se aplican al propietario.
- Los tres siguientes se aplican al grupo.
- Los tres últimos se aplican a los demás usuarios.

En el ejemplo, `/opt/mi-servicio` puede ser leído y recorrido por el propietario y el grupo, pero no por los demás usuarios. El archivo `config.yml` puede ser leído y modificado por su propietario, leído por el grupo, y queda oculto para los demás.

Crea una cuenta de servicio sin acceso interactivo y asígnale toda la carpeta:

```bash
sudo useradd --system --user-group --home-dir /opt/mi-servicio --shell /usr/sbin/nologin miservicio
sudo chown -R miservicio:miservicio /opt/mi-servicio

```

- `useradd` crea una cuenta.
- `--system` la identifica como cuenta de servicio.
- `--user-group` crea también un grupo `miservicio`.
- `--home-dir /opt/mi-servicio` asigna la carpeta de la aplicación.
- `--shell /usr/sbin/nologin` impide una sesión normal en el terminal.
- `chown -R` cambia el propietario y el grupo de forma recursiva.

Protege un archivo de configuración que contiene un secreto:

```bash
sudo chmod 640 /opt/mi-servicio/config/config.yml

```

- `6` concede lectura y escritura al propietario.
- `4` concede solo lectura al grupo.
- `0` no concede ningún acceso a los demás.

Para cambiar los permisos de todo un directorio que ya contiene archivos, utiliza un comando recursivo:

```bash
sudo chmod -R u=rwX,g=rX,o= /opt/mi-servicio

```

- `chmod -R` aplica los permisos a todo el contenido existente.
- `u=rwX` concede al propietario lectura, escritura y acceso a carpetas.
- `g=rX` concede al grupo lectura y acceso a carpetas.
- `o=` elimina todos los permisos para los demás usuarios.
- La `X` mayúscula añade ejecución solo a carpetas y a archivos que ya eran ejecutables, evitando que todos los archivos se vuelvan ejecutables por error.

Esto resulta útil después de extraer un archivo comprimido, subir archivos por SFTP o restaurar una copia de seguridad, cuando el propietario no es correcto o los permisos son demasiado abiertos.

No utilices `chmod -R 777` como solución general. Concede a todos los usuarios locales permiso para leer, modificar y ejecutar el contenido. Oculta el problema real y debilita la seguridad.

> **Referencia de Windows:** el propietario, el grupo y los permisos cumplen una función parecida a la propiedad y las listas de control de acceso NTFS.

## Vigilar CPU, memoria, disco y procesos

Abre la vista interactiva de procesos:

```bash
htop

```

- `htop` muestra CPU, memoria y procesos en ejecución.
- Utiliza las flechas para desplazarte y `F10` o `q` para salir.

> **Referencia de Windows:** `htop` es el equivalente más cercano al Administrador de tareas.

Comprueba la memoria:

```bash
free -h

```

- `free` muestra el uso de RAM y swap.
- `-h` utiliza unidades legibles.
- Linux puede reutilizar la memoria de caché, por lo que `available` suele ser más útil que `free`.

Comprueba el espacio en disco:

```bash
df -h

```

- `df` muestra el espacio libre y utilizado de los sistemas de archivos montados.
- `-h` utiliza GB y MB.
- Presta atención a la línea montada en `/`.

Ejemplo de salida para `free -h` y `df -h /`:

```plaintext
Mem: 15Gi 554Mi 14Gi
Swap: 7.8Gi 0B 7.8Gi
/dev/sda2 99G 12G 83G 12% /

```

Aquí el sistema de archivos principal montado en `/` está usado al 12 %, y el resumen de memoria muestra que la mayor parte de la RAM sigue disponible.

Mide una carpeta:

```bash
du -sh /opt/mi-servicio

```

- `du` mide el espacio utilizado.
- `-s` muestra un único total.
- `-h` utiliza unidades legibles.
- La ruta selecciona la carpeta.

Busca procesos por nombre:

```bash
ps aux | grep miservicio

```

- `ps aux` enumera procesos, propietarios y recursos.
- `|` envía la lista al comando siguiente.
- `grep miservicio` conserva las líneas que contienen ese texto.
- El propio comando `grep` también puede aparecer en el resultado.

> **Referencia de Windows:** `free`, `df`, `du` y `ps` se relacionan con las pestañas Rendimiento y Detalles del Administrador de tareas, la configuración de almacenamiento y las propiedades de una carpeta.

## Comprobar puertos y probar un servicio local

Muestra los sockets TCP y UDP que escuchan:

```bash
sudo ss -tulpn

```

- `ss` muestra conexiones y sockets de red.
- `-t` incluye TCP.
- `-u` incluye UDP.
- `-l` conserva los sockets en escucha.
- `-p` muestra el proceso asociado cuando los permisos lo permiten.
- `-n` mantiene las direcciones y los puertos en formato numérico.

Ejemplo de líneas útiles:

```plaintext
tcp LISTEN 0 4096 0.0.0.0:22 0.0.0.0:* users:(("sshd"))
tcp LISTEN 0 511 0.0.0.0:80 0.0.0.0:* users:(("nginx"))

```

`0.0.0.0:22` significa que SSH escucha en todas las interfaces IPv4. `127.0.0.1:8080` significaría que el servicio solo escucha desde el propio VPS.

Busca un puerto concreto:

```bash
sudo ss -tulpn | grep ':8080'

```

- El primer comando crea la lista de sockets.
- `|` la envía a `grep`.
- `grep ':8080'` conserva las líneas que contienen el puerto `8080`.

Prueba un servicio web desde el propio VPS:

```bash
curl -I http://127.0.0.1:8080

```

- `curl` envía la petición HTTP.
- `-I` solicita solo las cabeceras de la respuesta.
- `127.0.0.1` significa esta misma máquina.
- `:8080` selecciona el puerto `8080`.

Una respuesta local como `HTTP/1.1 200 OK` indica que la aplicación responde desde el propio VPS. Si el mismo servicio no es accesible desde Internet, revisa la dirección de escucha, el firewall Linux, las reglas de red disponibles en BoxToPlay y el proxy inverso.

> **Referencia de Windows:** estas comprobaciones se parecen a `Get-NetTCPConnection` e `Invoke-WebRequest` en PowerShell.

Que un proceso escuche localmente no significa que sea accesible desde Internet. La dirección de escucha, el firewall Linux, las reglas de red disponibles en BoxToPlay y el proxy inverso también intervienen.

## Mantener una aplicación activa con systemd

Una aplicación iniciada directamente desde SSH puede depender del terminal. `systemd` es el gestor de servicios de la mayoría de servidores Debian y Ubuntu actuales. Puede iniciar una aplicación al arrancar, reiniciarla tras un fallo y recopilar sus logs.

En este ejemplo, la aplicación proporciona `/opt/mi-servicio/start.sh`. Adapta siempre esta ruta a la documentación del software.

Haz ejecutable el script de arranque y asigna los archivos a la cuenta del servicio:

```bash
sudo chmod +x /opt/mi-servicio/start.sh
sudo chown -R miservicio:miservicio /opt/mi-servicio

```

- `chmod +x` añade el derecho de ejecutar el script.
- `chown -R` asigna la aplicación de forma recursiva a la cuenta `miservicio`.

Crea la definición del servicio:

```bash
sudo nano /etc/systemd/system/miservicio.service

```

- `sudo` permite escribir en `/etc`.
- `nano` abre el editor.
- Los archivos terminados en `.service` definen servicios systemd.

Ejemplo:

```ini
[Unit]
Description=Mi servicio alojado
After=network-online.target

[Service]
Type=simple
User=miservicio
Group=miservicio
WorkingDirectory=/opt/mi-servicio
ExecStart=/opt/mi-servicio/start.sh
Restart=on-failure

[Install]
WantedBy=multi-user.target

```

- `[Unit]` describe el servicio y sus dependencias de arranque.
- `After=network-online.target` lo sitúa después del objetivo de red disponible.
- `[Service]` define cómo se ejecuta el proceso.
- `User` y `Group` evitan ejecutarlo como root.
- `WorkingDirectory` establece la carpeta de trabajo.
- `ExecStart` indica el ejecutable y sus argumentos exactos. No es una línea de shell sin restricciones.
- `Restart=on-failure` reinicia el proceso después de un fallo inesperado.
- `[Install]` define cómo se vincula al arranque normal del sistema.

Pide a systemd que vuelva a leer sus archivos:

```bash
sudo systemctl daemon-reload

```

- `systemctl` administra systemd.
- `daemon-reload` recarga las definiciones sin reiniciar todo el VPS.

Activa e inicia el servicio:

```bash
sudo systemctl enable --now miservicio

```

- `enable` configura el inicio automático.
- `--now` también lo inicia inmediatamente.
- `miservicio` hace referencia a `miservicio.service`.

Comprueba su estado:

```bash
sudo systemctl status miservicio

```

- `status` indica si está activo e incluye las últimas líneas del log.
- Pulsa `q` si la salida se abre en un visor.

Reinícialo después de cambiar la configuración:

```bash
sudo systemctl restart miservicio

```

- `restart` detiene y vuelve a iniciar el servicio.
- Utilízalo después de guardar y, cuando sea posible, validar la configuración.

> **Referencia de Windows:** los servicios systemd corresponden a los Servicios de Windows. `systemctl` cumple una función similar a la consola Servicios o `sc.exe`.

## Leer los logs con journalctl

Muestra el log del servicio:

```bash
sudo journalctl -u miservicio

```

- `journalctl` lee los logs recopilados por systemd.
- `-u miservicio` filtra una unidad concreta.

Muestra las últimas líneas y sigue las nuevas:

```bash
sudo journalctl -u miservicio -n 100 -f

```

- `-n 100` empieza por las 100 últimas líneas.
- `-f` sigue las nuevas líneas en tiempo real.
- Pulsa `Ctrl+C` para dejar de seguirlas sin detener el servicio.

Muestra los logs desde el arranque actual:

```bash
sudo journalctl -u miservicio -b

```

- `-b` limita el resultado al arranque actual del sistema.

> **Referencia de Windows:** `journalctl` desempeña una función similar al Visor de eventos, mientras que `-f` permite observar un log que se actualiza en directo.

## Configurar un firewall sin perder el acceso

Ubuntu utiliza con frecuencia UFW como interfaz sencilla del firewall. Debian puede utilizar nftables directamente o no incluir UFW. Utiliza un solo método de gestión para que las reglas sigan siendo comprensibles.

Instala UFW únicamente si has decidido utilizarlo:

```bash
sudo apt install ufw

```

- `apt install` instala la herramienta de gestión del firewall.
- Instalar UFW no lo activa automáticamente.

Muestra su estado antes de añadir o activar nada:

```bash
sudo ufw status verbose

```

- `ufw` gestiona el firewall.
- `status` indica si está `active` o `inactive`.
- `verbose` añade las políticas predeterminadas y más detalles.
- Este comando no modifica ninguna regla.

En un servidor donde UFW todavía no está activo, puedes ver:

```plaintext
Status: inactive

```

Esto significa que la herramienta está presente, pero este firewall no está aplicando reglas en ese momento.

Comprueba que exista el perfil SSH predefinido:

```bash
sudo ufw app list

```

- `app list` muestra los perfiles de aplicaciones registrados en UFW.
- Confirma que aparece `OpenSSH` antes de utilizar ese nombre de perfil.

Autoriza SSH antes de la primera activación:

```bash
sudo ufw allow OpenSSH

```

- `ufw allow` añade una regla de entrada.
- `OpenSSH` suele cubrir el puerto TCP `22` y mantiene disponible el acceso SSH de administración.
- Esta regla no abre el puerto de tu aplicación.

Autoriza un puerto SSH personalizado cuando sea necesario:

```bash
sudo ufw allow 2222/tcp

```

- `2222` es el puerto de ejemplo que debes sustituir.
- `/tcp` limita la regla al protocolo TCP utilizado por SSH.

Si el primer estado era `inactive`, activa UFW únicamente después de preparar la regla SSH:

```bash
sudo ufw enable

```

- `enable` activa el firewall y las reglas preparadas.
- Si UFW ya estaba activo, las nuevas reglas se aplican de inmediato y este comando no es necesario.
- Mantén abierta la sesión existente mientras pruebas una segunda conexión SSH.

Comprueba las reglas resultantes:

```bash
sudo ufw status numbered

```

- `status numbered` enumera las reglas activas con números que permiten gestionarlas más adelante.

Abre los puertos web normales únicamente cuando alojes un sitio público:

```bash
sudo ufw allow 80/tcp
sudo ufw allow 443/tcp

```

- El puerto `80/tcp` se utiliza para HTTP.
- El puerto `443/tcp` se utiliza para HTTPS.

Abre un puerto de aplicación como `8080/tcp` solo cuando quieras que esa aplicación sea accesible directamente desde Internet. Para una aplicación web detrás de Nginx o Apache, conserva la aplicación en `127.0.0.1:8080` y abre solo los puertos públicos del proxy.

> **Referencia de Windows:** UFW es comparable a las reglas del Firewall de Windows Defender. Las reglas de red disponibles en BoxToPlay, cuando están configuradas, añaden otra capa parecida a un firewall externo.

Si la imagen del sistema o la configuración entregada con el VPS ya gestiona nftables o iptables, no actives UFW por encima. Puedes consultar la configuración existente sin modificarla:

```bash
sudo nft list ruleset
sudo iptables -S

```

- `nft list ruleset` muestra todas las reglas que conoce nftables.
- `iptables -S` muestra las reglas actuales de iptables en forma de comandos.
- Ambos comandos son de solo lectura. Sigue el método de la distribución o la documentación BoxToPlay asociada a esas reglas.

Conserva siempre el acceso SSH y una consola de recuperación.

## Añadir un dominio, un proxy inverso y HTTPS

Una aplicación web suele escuchar solo en `127.0.0.1:8080`. Un proxy inverso como Nginx recibe las peticiones públicas en los puertos 80 y 443 y las reenvía a la aplicación interna.

Si la aplicación no incluye ya una autenticación fiable, no la expongas directamente a todo Internet. Añade una protección dedicada, por ejemplo Basic Auth en Nginx, una restricción por IP o un acceso privado.

El orden habitual es:

1. Crear el registro DNS del dominio apuntando a la IP del VPS.
2. Mantener la aplicación en un puerto local cuando sea posible.
3. Configurar Nginx para el dominio.
4. Validar la configuración.
5. Obtener un certificado HTTPS.

Instala Nginx:

```bash
sudo apt install nginx

```

- `apt install` instala Nginx y su servicio systemd.
- El paquete suele iniciar el servidor web automáticamente.

Crea un archivo de sitio:

```bash
sudo nano /etc/nginx/sites-available/ejemplo.com

```

- El nombre suele coincidir con el dominio para facilitar su identificación.
- `sites-available` guarda las configuraciones disponibles.

Ejemplo:

```nginx
server {
    listen 80;
    server_name ejemplo.com;

    location / {
        proxy_pass http://127.0.0.1:8080;
        proxy_http_version 1.1;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $remote_addr;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

```

- `listen 80` acepta conexiones HTTP.
- `server_name` selecciona las peticiones para el dominio.
- `location /` se aplica a todas las rutas.
- `proxy_pass` reenvía las peticiones a la aplicación local.
- Las cabeceras reenviadas ayudan a la aplicación a conocer la dirección original del visitante y el protocolo usado.

Activa el sitio:

```bash
sudo ln -s /etc/nginx/sites-available/ejemplo.com /etc/nginx/sites-enabled/ejemplo.com

```

- `ln` crea un enlace.
- `-s` crea un enlace simbólico en lugar de una segunda copia.
- Nginx lee los enlaces de los sitios activos en `sites-enabled`.

Valida la configuración:

```bash
sudo nginx -t

```

- `nginx` ejecuta el programa Nginx.
- `-t` comprueba la sintaxis sin aplicarla.

Un resultado correcto se parece a este:

```plaintext
nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful

```

Recarga Nginx solo después de una validación correcta:

```bash
sudo systemctl reload nginx

```

- `reload` pide a Nginx que vuelva a leer la configuración sin interrumpir el servicio.

Para generar un certificado HTTPS en Debian o Ubuntu con Nginx, instala Certbot y lanza el asistente de Nginx:

```bash
sudo apt install certbot python3-certbot-nginx
sudo certbot --nginx -d ejemplo.com

```

- `python3-certbot-nginx` permite a Certbot leer y adaptar la configuración de Nginx.
- `certbot --nginx` solicita el certificado y puede añadir automáticamente la configuración HTTPS.
- Sustituye `ejemplo.com` por tu dominio real y sigue las preguntas mostradas por Certbot.

> **Referencia de Windows:** Nginx como proxy inverso es comparable a IIS con reglas de proxy y un certificado TLS.

## Crear una copia de seguridad antes de actualizar

Una copia de seguridad solo es útil si contiene los datos necesarios y puede restaurarse.

El ejemplo siguiente guarda solo `/opt/mi-servicio`. Si la aplicación utiliza MySQL, MariaDB, PostgreSQL u otra base de datos, prepara también un export específico de esa base.

Crea un archivo comprimido y limita su lectura a tu cuenta:

```bash
backup=~/copias/mi-servicio-$(date +%F-%H%M).tar.gz
mkdir -p ~/copias
sudo tar -czf "$backup" -C /opt mi-servicio
sudo chown "$USER":"$(id -gn)" "$backup"
chmod 600 "$backup"
tar -tzf "$backup" | head

```

- `backup=...` guarda la ruta del archivo una sola vez para reutilizarla en las órdenes siguientes.
- `mkdir -p ~/copias` crea la carpeta de copias en tu directorio personal.
- `tar -czf` crea (`c`) un archivo comprimido con gzip (`z`) en el archivo indicado (`f`).
- `$(date +%F-%H%M)` inserta la fecha y la hora en el nombre.
- `-C /opt mi-servicio` pide a `tar` que se sitúe en `/opt` y archive la carpeta `mi-servicio`.
- `chown` devuelve el archivo a la cuenta conectada para poder descargarlo.
- `chmod 600` limita el acceso al propietario porque una copia puede contener secretos.
- `tar -tzf` enumera el contenido para confirmar que el archivo puede leerse.

Ejemplo de salida:

```plaintext
mi-servicio/
mi-servicio/config/
mi-servicio/config/config.yml

```

Esto no prueba que toda la restauración vaya a funcionar, pero ya detecta un archivo ilegible o vacío.

Sincroniza la carpeta con otro destino montado:

```bash
sudo rsync -a /opt/mi-servicio/ /mnt/copias/mi-servicio/

```

- `rsync` sincroniza dos carpetas.
- `-a` copia de forma recursiva y conserva los metadatos habituales.
- La barra final de `/opt/mi-servicio/` indica que se copia su contenido.
- Si más adelante quieres reflejar también las eliminaciones, prueba primero en una carpeta desechable y revisa con cuidado las rutas de origen y destino.

> **Referencia de Windows:** `rsync` tiene una finalidad parecida a `robocopy`, y un archivo tar se parece a una copia ZIP. Ninguno constituye una copia externa si permanece en el mismo disco del VPS.

Conserva al menos una copia en otra máquina o servicio de almacenamiento y prueba una restauración en una carpeta aislada.

## Mantener el VPS

Para una comprobación regular:

```bash
sudo apt update
sudo apt upgrade
sudo systemctl --failed
df -h
free -h

```

- `apt update` busca las versiones de paquetes disponibles.
- `apt upgrade` propone su instalación.
- `systemctl --failed` enumera los servicios systemd actualmente en fallo.
- `df -h` comprueba el espacio en disco.
- `free -h` comprueba la memoria.

> **Referencia de Windows:** esto agrupa el papel de Windows Update, la consola Servicios, el Administrador de tareas y la vista de Almacenamiento.

Lee los cambios propuestos antes de una actualización importante, y después comprueba el estado y los logs de tus servicios.

## Flujo seguro para instalar cualquier servicio

Cuando instales un sitio web, bot, API, base de datos o herramienta de juego, sigue este orden:

1. Lee los requisitos oficiales e identifica el runtime, los puertos y las carpetas persistentes.
2. Conéctate por SSH con la cuenta `root` de BoxToPlay.
3. Instala únicamente las dependencias necesarias con `apt`.
4. Crea una carpeta dedicada en `/opt` o utiliza la ruta documentada.
5. Sube o descarga los archivos desde la fuente oficial.
6. Inspecciona los archivos comprimidos antes de extraerlos en una carpeta aislada.
7. Crea una cuenta de servicio y aplica permisos limitados.
8. Guarda la configuración y los secretos con acceso restrictivo.
9. Ejecuta la aplicación localmente y lee sus logs.
10. Configura un inicio duradero con systemd o Docker.
11. Prueba el puerto local en `127.0.0.1`.
12. Configura el firewall, DNS, proxy inverso y HTTPS cuando sea necesario.
13. Prepara una copia de seguridad y comprueba una restauración.

Si la aplicación encaja mejor en un contenedor, continúa con nuestra guía: [Instalar Docker en Linux: guía práctica para empezar](https://www.boxtoplay.com/es/news/instalar-docker-en-linux-guia-practica-para-empezar-31748).

## Lista de comprobación del VPS

Antes de publicar un servicio, confirma que:

- entiendes cada comando antes de ejecutarlo.
- la zona horaria es correcta y el reloj está sincronizado.
- has comprobado la estrategia de actualizaciones automáticas de seguridad.
- puedes conectarte como `root` y sabes si cualquier usuario adicional tiene permisos `sudo`.
- la autenticación con clave SSH funciona desde un segundo terminal.
- el sistema y los paquetes están actualizados.
- la aplicación se ejecuta con una cuenta dedicada.
- los archivos de configuración y los secretos no son legibles por todos.
- sabes inspeccionar CPU, memoria, disco, procesos, puertos y logs.
- el firewall mantiene SSH disponible y abre solo los puertos necesarios.
- la aplicación puede volver a iniciarse después de reiniciar el VPS.
- existe una copia fuera del VPS y has probado una restauración.

## Elegir un VPS adecuado para el servicio

Una buena instalación también necesita CPU, RAM, almacenamiento y red suficientes. Puedes comparar las configuraciones disponibles en la página de [alquiler de servidores VPS de BoxToPlay](https://www.boxtoplay.com/es/alquiler-vps/servidor-vps).

Empieza con los recursos que la aplicación necesita realmente, mide el uso y aumenta el plan solo cuando los datos lo justifiquen.