Cloud Server con despliegue IA

Actúa como mi ingeniero DevOps. Vas a publicar mi aplicación en mi Cloud Server
de Donweb. Yo no sé de servidores, así que explícame cada paso importante en una
frase simple antes de ejecutarlo.

DATOS DEL SERVIDOR (de mi panel de Donweb):

• IP: {IP_DEL_SERVIDOR}
• Hostname: {HOSTNAME} ← aparece como "Host" en el panel, ej: vps-57585926-x.dattaweb.com
• Puerto SSH: {PUERTO_SSH} ← atención: en Donweb no es el 22, revisa "Puerto" en el panel
• Usuario: root
• Sistema operativo: {SISTEMA_OPERATIVO} (Ej: Ubuntu 24.04 instalación mínima, recién creado)
  ← atención: revisa primero que corresponda con el SO del servidor

MI APLICACIÓN:

• Ubicación: {RUTA_LOCAL_ABSOLUTA_O_URL_DEL_REPO}
• El repositorio es: {público / privado / no es un repo, es una carpeta local}
• Tipo: {ej: Node.js / PHP / sitio estático — si no lo sabes, examina el código y dime}
• Puerto interno en el que corre (si aplica): {ej: 3000}
• Variables de entorno / claves que necesita: {ej: DATABASE_URL, API_KEY... / no sé}

CONTEXTO DEL SERVIDOR:

• Mi Cloud Server ya tiene un firewall virtual administrado desde el panel de
  Donweb, con los puertos 80, 443 y {PUERTO_SSH} abiertos. NO instales ni
  actives otro firewall (ufw/iptables) dentro del servidor: no hace falta y
  podría dejarme afuera.

REGLAS DE SEGURIDAD (obligatorias):

1. Nunca escribas, muestres ni guardes mi contraseña en texto plano. La única
   vez que se necesita es en el paso 1 (ssh-copy-id): ahí me detendré a
   escribirla yo. No uses sshpass ni ningún método que requiera ponerla en
   un comando o archivo.
2. Antes de cualquier acción destructiva (borrar archivos, formatear, reinstalar
   servicios existentes), avísame y espera mi confirmación.
3. No leas, resumas ni reportes /var/log/auth.log, la salida de lastb, el
   correo del sistema ni los intentos de login fallidos, salvo que yo te lo
   pida explícitamente. Los intentos de login fallidos en una IP pública son
   ruido normal de internet: no los presentes como hallazgo de seguridad ni
   listes IPs o direcciones involucradas.

REGLAS DE EJECUCIÓN (para que nada se quede colgado):

• En la PRIMERA conexión SSH usa -o StrictHostKeyChecking=accept-new para que
  no quede esperando una confirmación interactiva.
• En el servidor, ejecuta apt siempre con DEBIAN_FRONTEND=noninteractive y
  NEEDRESTART_MODE=a para evitar menús interactivos.
• No hagas un upgrade completo del sistema en este primer deploy: solo
  apt update e instala lo que haga falta.
• Estoy en Windows: rsync no existe aquí; para copiar archivos usa scp
  (recuerda que scp usa -P mayúscula para el puerto). git clone solo si el
  repo es público; si es privado o es una carpeta local, copia desde mi
  máquina con scp.
• Si mi aplicación necesita una base de datos u otro servicio (Postgres,
  MySQL, Redis...), avísame y explícame qué vas a instalar antes de hacerlo.

PASOS:

0. Verifica que {RUTA_LOCAL_ABSOLUTA_O_URL_DEL_REPO} existe y es accesible.
   Si no, detente y pregúntame antes de tocar el servidor.
1. Configura el acceso por clave SSH (así solo escribo mi contraseña UNA vez):
   genera una clave en mi máquina si no tengo una (ssh-keygen, sin passphrase,
   ruta por defecto) y cópiala al servidor con
   ssh-copy-id -p {PUERTO_SSH} -o StrictHostKeyChecking=accept-new root@{IP_DEL_SERVIDOR}
   — ahí el sistema me pedirá la contraseña y la escribo yo. Verifica después
   que puedes entrar sin contraseña. Todo lo que sigue debe ser no-interactivo.
2. Conéctate por SSH y verifica que el servidor responde. Muéstrame sistema,
   memoria y disco disponibles.
3. Prepara el servidor: actualiza el índice de paquetes e instala lo que mi
   aplicación necesite (runtime, nginx). Si la app es Node.js, detecta la
   versión que requiere (package.json → engines, .nvmrc, o dependencias) e
   instálala desde NodeSource — la versión de los repos de Ubuntu es vieja.
   Si el servidor tiene 1-2 GB de RAM, crea un archivo swap de 1 GB.
4. Sube mi aplicación a /opt/{NOMBRE_APP} (scp desde mi carpeta, o git clone
   si es un repo público). Instala sus dependencias si tiene.
5. Si detectas un .env.example, un .env faltante o referencias a variables de
   entorno no definidas, detente y pregúntame los valores antes de arrancar
   la aplicación. Guarda el .env en el servidor con permisos 600.
6. Configura mi aplicación como servicio del sistema (systemd) para que
   arranque sola si el servidor se reinicia, y verifica que quede corriendo.
7. Configura nginx como proxy inverso: el puerto 80 debe servir mi aplicación,
   respondiendo tanto por la IP como por el hostname {HOSTNAME}.
   Verifica la configuración antes de recargar nginx.
8. Verifica el resultado: haz una petición HTTP a http://{HOSTNAME}
   desde fuera del servidor y prueba también la funcionalidad principal
   (formulario, API, lo que tenga).
9. Entrégame un resumen: la URL donde vive mi app (http://{HOSTNAME}),
   qué instalaste, dónde quedaron los archivos, y los 3 comandos que me
   conviene conocer (ver estado, ver logs, reiniciar la app).

FASE OPCIONAL A — MI DOMINIO + HTTPS (pregúntame si quiero hacerla ahora):

10. Quiero que mi app responda en {MI_DOMINIO_O_SUBDOMINIO}. Guíame para crear
    el registro DNS: un registro A apuntando a {IP_DEL_SERVIDOR}, en el panel
    de DNS de Donweb, Cloudflare u otro proveedor (dime exactamente qué campos
    completar según cuál use). Luego verifica con dig/nslookup que el dominio
    ya resuelve a mi IP — si todavía no propaga, dime cuánto suele tardar y esperemos.
11. Cuando resuelva: configura nginx para responder por ese dominio y agrega
    HTTPS con un certificado gratuito de Let's Encrypt (certbot), con
    renovación automática. Verifica que https://{MI_DOMINIO_O_SUBDOMINIO} responde.

FASE OPCIONAL B — SEGURIDAD EXTRA (pregúntame si quiero hacerla ahora):

12. Crear un usuario no-root para administrar la app, verificar que mi clave
    SSH del paso 1 también funciona para ese usuario en una sesión nueva, y
    solo entonces deshabilitar el login por contraseña.

Si algo falla, explícame el error en lenguaje simple, dime si es grave, y
propón la solución antes de aplicarla.