DEV Community: Oscar Ricardo Sánche Gutierréz

RustDesk: How to Create a Secure Private Remote Access Network

Oscar Ricardo Sánche Gutierréz — Tue, 31 Mar 2026 00:47:18 +0000

RustDesk is the perfect solution for secure remote access, open-source and under your complete control. In this article I'll show you how to deploy your own server, configure it as a closed network, and secure it for corporate use.

Diagram created with https://savnet.co

RustDesk is an open-source alternative to tools like TeamViewer or AnyDesk, but with a key advantage: you can self-host it. This means:

Complete control over your data
No connection limits
Zero licensing costs (only server costs)

Step 1: Prepare the Server

You'll need a Linux server with Ubuntu 22.04 or 24.04 LTS with:

1 vCPU, 2 GB RAM (enough for dozens of connections)
Ubuntu 22.04 LTS or higher
Fixed public IP

Step 2: Initial Server Configuration

Connect via SSH and update the system:

ssh root@your_server_ip
apt update && apt upgrade -y
timedatectl set-timezone America/New_York  # Adjust to your timezone
reboot

Step 3: Install Docker and Docker Compose

Follow the official Docker installation:

# Install dependencies
apt install -y ca-certificates curl gnupg

# Add official Docker repository
install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc
chmod a+r /etc/apt/keyrings/docker.asc

echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] \
  https://download.docker.com/linux/ubuntu \
  $(. /etc/os-release && echo "$VERSION_CODENAME") stable" \
  | tee /etc/apt/sources.list.d/docker.list > /dev/null

# Install Docker
apt update
apt install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

# Verify installation
docker --version
docker compose version

Step 4: Prepare RustDesk Structure

mkdir -p /opt/rustdesk-server/data
cd /opt/rustdesk-server

Step 5: Create the docker-compose.yml File

Create nano /opt/rustdesk-server/compose.yml:

services:
  hbbr:
    container_name: hbbr
    image: rustdesk/rustdesk-server:latest
    command: hbbr
    volumes:
      - ./data:/root
    network_mode: "host"
    restart: unless-stopped

  hbbs:
    container_name: hbbs
    image: rustdesk/rustdesk-server:latest
    command: hbbs
    volumes:
      - ./data:/root
    network_mode: "host"
    depends_on:
      - hbbr
    restart: unless-stopped

Important: We use network_mode: "host" because RustDesk needs to see the real host IP to function correctly.

Step 6: Start the Services

# Start services
docker compose up -d

# Verify they're running
docker ps

# View logs
docker compose logs

Step 7: Get the Server Public Key

This key is crucial for clients to trust your server:

cat /opt/rustdesk-server/data/id_ed25519.pub && echo ""

Save the result. It will look something like:

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=

Step 8: Configure the Firewall

Ports needed for RustDesk OSS:

TCP 21115 - Main service
TCP 21116 - ID service
UDP 21116 - For better performance
TCP 21117 - Relay service

Configure UFW on the server:

# Install firewall ufw
apt install -y ufw

# Allow SSH from YOUR public IP
ufw allow from your_admin_ip to any port 22
# IF YOU DON'T HAVE a public IP, allow any origin with
ufw allow 22

# Allow RustDesk ports
ufw allow 21115/tcp
ufw allow 21116/tcp
ufw allow 21116/udp
ufw allow 21117/tcp

# Enable firewall
ufw enable
ufw status verbose

Configure cloud provider firewall:

In your cloud provider panel, create Inbound rules that allow only from your corporate IPs:

Step 9: Configure Computer/Client

On each computer:

Open RustDesk
Go to Settings → Network
Click Unlock Network Settings
Go to Server ID/Relay
Configure:
- ID Server: YourRustServerIP
- Relay Server: YourRustServerIP
- Key: Paste the public key obtained in step 7
- API Server: Leave empty (only for RustDesk Pro)

If you want to quickly use your configuration, click the copy icon in the top right corner, and the paste icon to import:

Ways to Improve Your RustDesk Client Security

RustDesk offers multiple authentication methods to securely control remote access. Here I explain each option:

1. One-time password

Automatically generated for each session and the user must provide it to the remote technician to connect
Length options: 6, 8, or 10 digits
The key changes with each session
Ideal use: Temporary technical support or occasional access

2. Permanent password

Key you specify manually that doesn't change between sessions
Allows continuous access without needing to share new keys
Ideal use: Frequent remote access to your own computer

3. Both passwords

Flexibility to use temporary OR permanent password
Ideal use: Mixed scenarios (personal use + occasional support)

4. Two-Factor Authentication (2FA)

Additional security layer
Options: codes from authenticator app or Telegram bot integration
Ideal use: Computers accessible from public internet

5. Trusted devices

Only applies when using 2FA
Mark specific devices as trusted
Avoids requesting 2FA on each connection from those devices
Improves convenience while maintaining security

6. Additional Security Settings

Password length: Configurable based on security needs
Expiration time: For temporary passwords
Audit logging: Access monitoring

Practical Recommendations:

For frequent personal use: Permanent password + optional 2FA

For technical support: One-time password

For corporate environments: Mandatory 2FA + trusted devices

For maximum security: Combination of methods + audit logging

These methods allow you to balance security and convenience according to your specific needs.

How to Make This a Truly Closed Network

1. Block Access from Public Internet on the RustDesk Server

Don't allow access from any IP in the firewall ufw rules or cloud provider rules. Only allow:

Your office IPs
Your corporate VPN IP
Specific authorized ranges

2. Implement VPN for Remote Access

The most secure way: remote users first connect to the corporate VPN, then access RustDesk.

3. Create Administrative User Without Root:

adduser adminops
usermod -aG sudo adminops

mkdir -p /home/adminops/.ssh
cp /root/.ssh/authorized_keys /home/adminops/.ssh/authorized_keys
chown -R adminops:adminops /home/adminops/.ssh
chmod 700 /home/adminops/.ssh
chmod 600 /home/adminops/.ssh/authorized_keys

# Disable root SSH
if grep -q '^PermitRootLogin' /etc/ssh/sshd_config; then
  sed -i 's/^PermitRootLogin.*/PermitRootLogin no/' /etc/ssh/sshd_config
else
  echo 'PermitRootLogin no' >> /etc/ssh/sshd_config
fi

sshd -t && systemctl restart ssh

RustDesk Pro: For Advanced Enterprise Needs

The RustDesk version we've configured is excellent for basic remote access, but if you need advanced enterprise features, RustDesk offers a Pro version with additional capabilities:

Centralized user and group management
Granular access control (role-based permissions)
LDAP/Active Directory authentication
Detailed auditing and logs
Priority technical support
Mass management functions

For these organizations, you can check the Pro plans at https://rustdesk.com/pricing/.

Need a cloud server? You can get an Ubuntu Droplet on DigitalOcean using our referral link and receive initial credits to try this tutorial.

Have you implemented RustDesk in your organization? Share your experience in the comments!

RustDesk: Cómo crear una red de acceso remoto segura y privada

Oscar Ricardo Sánche Gutierréz — Tue, 31 Mar 2026 00:35:54 +0000

RustDesk es la solución perfecta para acceso remoto seguro, de código abierto y bajo tu control completo. En este artículo te mostraré cómo desplegar tu propio servidor, configurarlo como una red cerrada y asegurarlo para uso corporativo.

Diagrama realizado con https://savnet.co

RustDesk es una alternativa de código abierto a herramientas como TeamViewer o AnyDesk, pero con una ventaja clave: puedes autoalojarlo. Esto significa:

Control total sobre tus datos
Sin límites de conexión
Costo cero en licencias (solo el servidor)

Paso 1: Preparar el servidor

Necesitarás un servidor Linux con Ubuntu 22.04 o 24.04 LTS con:

1 vCPU, 2 GB RAM (suficiente para decenas de conexiones)
Ubuntu 22.04 LTS o superior
IP pública fija

Paso 2: Configuración inicial del servidor

Conéctate por SSH y actualiza el sistema:

ssh root@tu_ip_servidor
apt update && apt upgrade -y
timedatectl set-timezone America/Bogota  # Ajusta a tu zona horaria
reboot

Paso 3: Instalar Docker y Docker Compose

Sigue la instalación oficial de Docker:

# Instalar dependencias
apt install -y ca-certificates curl gnupg

# Agregar repositorio oficial de Docker
install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc
chmod a+r /etc/apt/keyrings/docker.asc

echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] \
  https://download.docker.com/linux/ubuntu \
  $(. /etc/os-release && echo "$VERSION_CODENAME") stable" \
  | tee /etc/apt/sources.list.d/docker.list > /dev/null

# Instalar Docker
apt update
apt install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

# Verificar instalación
docker --version
docker compose version

Paso 4: Preparar la estructura de RustDesk

mkdir -p /opt/rustdesk-server/data
cd /opt/rustdesk-server

Paso 5: Crear el archivo docker-compose.yml

Crea nano /opt/rustdesk-server/compose.yml:

services:
  hbbr:
    container_name: hbbr
    image: rustdesk/rustdesk-server:latest
    command: hbbr
    volumes:
      - ./data:/root
    network_mode: "host"
    restart: unless-stopped

  hbbs:
    container_name: hbbs
    image: rustdesk/rustdesk-server:latest
    command: hbbs
    volumes:
      - ./data:/root
    network_mode: "host"
    depends_on:
      - hbbr
    restart: unless-stopped

Importante: Usamos network_mode: "host" porque RustDesk necesita ver la IP real del host para funcionar correctamente.

Paso 6: Levantar los servicios

# Levantar servicios
docker compose up -d

# Verificar que estén corriendo
docker ps

# Ver logs
docker compose logs

Paso 7: Obtener la clave pública del servidor

Esta clave es crucial para que los clientes confíen en tu servidor:

cat /opt/rustdesk-server/data/id_ed25519.pub && echo ""

Guarda el resultado. Se verá algo como:

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=

Paso 8: Configurar el firewall

Puertos necesarios para RustDesk OSS:

TCP 21115 - Servicio principal
TCP 21116 - Servicio de ID
UDP 21116 - Para mejor rendimiento
TCP 21117 - Servicio de relay

Configurar UFW en el servidor:

# Instalar firewall ufw
apt install -y ufw

# Permitir SSH desde TU IP pública
ufw allow from tu_ip_admin to any port 22
# SI NO TIENES IP pública, permite cualquier origen con
ufw allow 22

# Permitir puertos de RustDesk
ufw allow 21115/tcp
ufw allow 21116/tcp
ufw allow 21116/udp
ufw allow 21117/tcp

# Activar firewall
ufw enable
ufw status verbose

Configurar firewall del proveedor cloud:

En el panel de tu proveedor cloud, crea reglas Inbound que permitan solo desde tus IPs corporativas:

Paso 9: Configurar computador/cliente

En cada equipo:

Abre RustDesk
Ve a Settings → Network
Haz click en Unlock Network Settings
Ve a Servidor ID/Relay
Configura:
- ID Server: IpServidorRust
- Relay Server: IpServidorRust
- Key: Pega la clave pública obtenida en el paso 7
- API Server: Déjalo vacío (solo para RustDesk Pro)

Si quieres usar rápidamente tu configuración da click en el icono de copiar en la parte superior derecha, y el icono de pegar para importar:

Formas de mejorar la seguridad de tu computador/cliente RustDesk

RustDesk ofrece múltiples métodos de autenticación para controlar el acceso remoto de forma segura. Aquí te explico cada opción:

1. Contraseña de un solo uso (One-time password)

Se genera automáticamente en cada sesión y el usuario debe suministrarla al técnico remoto para que pueda conectarse.
Opciones de longitud: 6, 8 o 10 dígitos
La clave cambia en cada sesión.
Uso ideal: Soporte técnico puntual o accesos temporales

2. Contraseña permanente (Permanent password)

Clave que especificas manualmente y no cambia entre sesiones
Permite acceso continuo sin necesidad de compartir nuevas claves
Uso ideal: Acceso remoto frecuente a tu propio equipo

3. Combinación de ambos métodos (Both passwords)

Flexibilidad para usar contraseña temporal O permanente
Uso ideal: Escenarios mixtos (uso personal + soporte ocasional)

4. Autenticación en dos factores (2FA)

Capa adicional de seguridad
Opciones: códigos desde app autenticadora o integración con bot de Telegram
Uso ideal: Equipos accesibles desde internet público

5. Dispositivos de confianza (Trusted devices)

Solo aplica cuando usas 2FA
Marcar dispositivos específicos como confiables
Evita solicitar 2FA en cada conexión desde esos dispositivos
Mejora la comodidad manteniendo seguridad

6. Configuraciones de seguridad adicionales

Longitud de contraseña: Configurable según necesidades de seguridad
Tiempo de expiración: Para contraseñas temporales
Registro de auditoría: Monitoreo de accesos

Recomendaciones prácticas:

Para uso personal frecuente: Contraseña permanente + 2FA opcional

Para soporte técnico: Contraseña de un solo uso

Para entornos corporativos: 2FA obligatorio + dispositivos de confianza

Para máxima seguridad: Combinación de métodos + registro de auditoría

Estos métodos te permiten balancear seguridad y conveniencia según tus necesidades específicas.

Cómo convertir esto en una red realmente cerrada

1. Bloquear acceso desde Internet público del servidor RustDesk

No permitas acceso a cualquier ip en las reglas del firewall ufw o del operador cloud. Solo permite:

IPs de tus oficinas
IP de tu VPN corporativa
Rangos específicos autorizados

2. Implementar VPN para acceso remoto

La forma más segura: usuarios remotos primero se conectan a la VPN corporativa, luego acceden a RustDesk.

3. Crear usuario administrativo sin root:

adduser adminops
usermod -aG sudo adminops

mkdir -p /home/adminops/.ssh
cp /root/.ssh/authorized_keys /home/adminops/.ssh/authorized_keys
chown -R adminops:adminops /home/adminops/.ssh
chmod 700 /home/adminops/.ssh
chmod 600 /home/adminops/.ssh/authorized_keys

# Deshabilitar root por SSH
if grep -q '^PermitRootLogin' /etc/ssh/sshd_config; then
  sed -i 's/^PermitRootLogin.*/PermitRootLogin no/' /etc/ssh/sshd_config
else
  echo 'PermitRootLogin no' >> /etc/ssh/sshd_config
fi

sshd -t && systemctl restart ssh

RustDesk Pro: Para necesidades empresariales avanzadas

La versión RustDesk que hemos configurado es excelente para acceso remoto básico, pero si necesitas funcionalidades empresariales avanzadas, RustDesk ofrece una versión Pro con características adicionales:

Gestión centralizada de usuarios y grupos
Control de acceso granular (permisos por rol)
Autenticación LDAP/Active Directory
Auditoría y logs detallados
Soporte técnico prioritario
Funciones de administración masiva

Para estas organizaciones puedes consultar los planes Pro en https://rustdesk.com/pricing/.

¿Necesitas un servidor en la nube? Puedes obtener un Droplet Ubuntu en DigitalOcean usando nuestro enlace de referido y recibir créditos iniciales para probar este tutorial.

¿Has implementado RustDesk en tu organización? ¡Comparte tu experiencia en los comentarios!

How to Deploy Dokploy on an Ubuntu Server and Create Your First "Hello World" in Node.js

Oscar Ricardo Sánche Gutierréz — Fri, 27 Mar 2026 22:41:28 +0000

Introduction

Dokploy is a self-hosted deployment platform that simplifies containerized application management using Docker Swarm. In this comprehensive tutorial, I'll show you how to install Dokploy on an Ubuntu server, configure security with firewalls, deploy your first Node.js application, and follow production best practices.

Diagram created with https://savnet.co

What You'll Need

Before starting, make sure you have:

An Ubuntu 24.04 LTS server (minimum 2 GB RAM for testing)
SSH access with configured keys
A domain or subdomain (optional but recommended for HTTPS)
Basic terminal and Docker knowledge

Step 1: Prepare Your Ubuntu Server

If you already have an Ubuntu 24.04 LTS server with SSH access, you can skip this step. If you need to create one, follow these recommendations:

Choose a cloud or VPS provider that offers Ubuntu 24.04 LTS
Select a plan with at least 2 GB of RAM for testing
Configure SSH key access instead of password (more secure)
Consider enabling backups and monitoring for production
Note the public IP of your server

If your provider has an integrated firewall (like DigitalOcean Cloud Firewall, AWS Security Groups, etc.), configure the necessary rules from the control panel.

Step 2: Initial Server Configuration

Connect to the server via SSH:

ssh root@YOUR_PUBLIC_IP

Update system and install utilities

apt update && apt upgrade -y
apt install -y curl wget git ufw ca-certificates gnupg lsb-release

Create administrator user (recommended)

adduser deploy
usermod -aG sudo deploy
rsync --archive --chown=deploy:deploy ~/.ssh /home/deploy

Now you can connect with the new user:

ssh deploy@YOUR_PUBLIC_IP

Step 3: Configure Firewall with UFW

Dokploy needs specific ports open. Configure UFW properly:

# Allow SSH first to avoid locking ourselves out
sudo ufw allow OpenSSH

# Open ports needed for Dokploy and applications
sudo ufw allow 80/tcp     # HTTP for Traefik
sudo ufw allow 443/tcp    # HTTPS for Traefik
sudo ufw allow 443/udp    # HTTPS UDP for Traefik
sudo ufw allow 3000/tcp   # Dokploy panel (temporary only)

# Enable firewall
sudo ufw enable
sudo ufw status numbered

Important: Docker can bypass UFW rules because it manipulates iptables directly. If your cloud provider offers an integrated firewall (like DigitalOcean Cloud Firewall, AWS Security Groups, etc.), we recommend configuring it as an additional security layer.

Configure the same firewall rules in your provider's panel:

22/TCP from your IP or trusted range (SSH)
80/TCP from Anywhere (HTTP)
443/TCP from Anywhere (HTTPS)
443/UDP from Anywhere (HTTPS UDP)
3000/TCP temporarily from your IP only (for initial setup)

assets/dropplet-firewall.png

Step 4: Install Dokploy

The official Dokploy installation is straightforward with their script:

curl -sSL https://dokploy.com/install.sh | sudo sh

This script automatically:

Installs Docker if not present
Initializes Docker Swarm
Creates the overlay network dokploy-network
Deploys Postgres, Redis, and Dokploy services
Launches Traefik as reverse proxy
Publishes the panel on port 3000

Step 5: Verify the Installation

Check that everything is working:

# View Docker Swarm services
docker service ls

# View running containers
docker ps

# Verify ports are listening
ss -lntup | grep -E '(:80|:443|:3000)'

Now open your browser and access the Dokploy panel:

http://YOUR_PUBLIC_IP:3000

Complete the initial setup wizard by creating your administrator account.

Step 6: Configure Domain and HTTPS (optional but recommended)

To access your applications with your own domain and HTTPS:

In your DNS provider's panel (Cloudflare, DigitalOcean, AWS Route53, etc.), add your domain if you haven't already.
Create DNS records:
- A record for @ pointing to your server IP
- A record for www pointing to your server IP
- Or a subdomain like dokploy.yourdomain.com

Wait for DNS propagation (may take a few minutes).

Restrict access to port 3000

For security, once Dokploy is configured, restrict access to port 3000:

In your cloud provider's firewall, limit it to your IP only if you need administrative access

Step 7: Deploy Your First "Hello World" Application in Node.js

Let's create a simple Node.js application and deploy it to Dokploy.

7.1 Create the project locally

Create a folder for your project with the following files:

package.json:

{
  "name": "hello-world-dokploy",
  "version": "1.0.0",
  "description": "Hello World application for Dokploy",
  "main": "app.js",
  "scripts": {
    "start": "node app.js"
  },
  "dependencies": {
    "express": "^4.18.2"
  }
}

app.js:

const express = require('express');
const app = express();
const PORT = 3000;

app.get('/', (req, res) => {
  res.json({
    message: 'Hello World from Dokploy!',
    timestamp: new Date().toISOString(),
    environment: process.env.NODE_ENV
  });
});

app.get('/health', (req, res) => {
  res.status(200).send('OK');
});

app.listen(PORT, () => {
  console.log(`Server running on port ${PORT}`);
});

Dockerfile:

FROM node:18-alpine
WORKDIR /app
COPY package*.json ./
RUN npm install --omit=dev
COPY . .
EXPOSE 3000
USER node
CMD ["node", "app.js"]

docker-compose.yml (for reference):

version: '3.8'
services:
  app:
    build: .
    environment:
      - NODE_ENV=staging
    restart: unless-stopped

7.2 Deploy to Dokploy

Deploy part 1

Deploy part 2

In the Dokploy panel, click Create Project
Give your project a name (e.g., "Tests")
In the project panel, click Create Service and select Application
Name your application: Hello World
Then access your application and in the bottom section Build Type select Dockerfile and then Save.
In the top section you have Provider. For this test we'll select the Drop type, however for real cases the best option is through git repository.
Once Drop is selected, drag to the Zip file area the zip with the code we specified in point 7.1.
Click the Deploy button
Once deployment is complete, it will show the Deployments tab where you should see a green dot and Done indicating the process was successful. You can click View to verify the process.
Now, to deploy our Hello World, go to the Domains tab.
For this test we'll use a free Traefik domain by clicking on the dice icon, specify that the Container Port is 3000 and enable HTTPS with Let's Encrypt provider.
Then click the Create button
When finished, it will give us a URL where we can enter and see our web. Important: since we're using a test domain it will give security warnings. For production environments use your own domain.

7.3 Verify the deployment

Once deployment is complete, access your application:

https://tests-hello-world-puloud-d13d9c-167-172-as2dsaccc234-151.traefik.me/

You should see the JSON "Hello World" message.

Step 8: Production Best Practices

1. Don't build on production server

Dokploy recommends building Docker images in CI/CD (GitHub Actions, GitLab CI) and then deploying the pre-built image. This saves resources and reduces downtime risk.

2. Use health checks

Configure health checks in your applications (like the /health endpoint in our example) so Docker Swarm can monitor status.

3. Configure backups

Configure regular server backups (if your provider offers this feature)
Configure regular database backups
Use docker volume for persistent data

4. Monitoring and logs

# View Dokploy logs
docker service logs dokploy --tail 100 -f

# View application logs
docker service logs hello-world_app --tail 100 -f

# View service status
docker service ps hello-world_app

Conclusion

Dokploy offers a robust, self-hosted solution for deploying applications on Docker Swarm. By implementing it on an Ubuntu server, you get a scalable, secure, and professional infrastructure at an accessible cost.

Need a cloud server? You can get an Ubuntu Droplet on DigitalOcean using our referral link and receive initial credits to try this tutorial.

Additional Resources

Enjoyed this tutorial? Share your experiences deploying applications with Dokploy in the comments or suggest topics for future articles.

Cómo desplegar Dokploy en un servidor Ubuntu y crear tu primer "Hola Mundo" en Node.js

Oscar Ricardo Sánche Gutierréz — Fri, 27 Mar 2026 22:38:03 +0000

Introducción

Dokploy es una plataforma de despliegue auto-hospedada que simplifica la gestión de aplicaciones en contenedores Docker usando Docker Swarm. En este tutorial completo, te mostraré cómo instalar Dokploy en un servidor Ubuntu, configurar seguridad con firewall, desplegar tu primera aplicación Node.js y seguir las mejores prácticas para producción.

Diagrama realizado con https://savnet.co

¿Qué necesitas?

Antes de comenzar, asegúrate de tener:

Un servidor con Ubuntu 24.04 LTS (2 GB de RAM mínimo para pruebas)
Acceso por SSH con claves configuradas
Un dominio o subdominio (opcional, pero recomendado para HTTPS)
Conocimientos básicos de terminal y Docker

Paso 1: Preparar tu servidor Ubuntu

Si ya tienes un servidor Ubuntu 24.04 LTS con acceso SSH, puedes saltar este paso. Si necesitas crear uno, sigue estas recomendaciones:

Elige un proveedor de cloud o VPS que ofrezca Ubuntu 24.04 LTS
Selecciona un plan con al menos 2 GB de RAM para pruebas
Configura acceso SSH con claves en lugar de contraseña (más seguro)
Considera activar backups y monitoreo si es para producción
Anota la IP pública de tu servidor

Si usas un proveedor con firewall integrado (como Cloud Firewall de DigitalOcean, Security Groups de AWS, etc.), configura las reglas necesarias desde el panel de control.

Paso 2: Configuración inicial del servidor

Conéctate al servidor por SSH:

ssh root@TU_IP_PUBLICA

Actualizar sistema e instalar utilidades

apt update && apt upgrade -y
apt install -y curl wget git ufw ca-certificates gnupg lsb-release

Crear usuario administrador (recomendado)

adduser deploy
usermod -aG sudo deploy
rsync --archive --chown=deploy:deploy ~/.ssh /home/deploy

Ahora puedes conectarte con el nuevo usuario:

ssh deploy@TU_IP_PUBLICA

Paso 3: Configurar firewall con UFW

Dokploy necesita puertos específicos abiertos. Configura UFW correctamente:

# Permitir SSH primero para no bloquearnos
sudo ufw allow OpenSSH

# Abrir puertos necesarios para Dokploy y aplicaciones
sudo ufw allow 80/tcp     # HTTP para Traefik
sudo ufw allow 443/tcp    # HTTPS para Traefik
sudo ufw allow 443/udp    # HTTPS UDP para Traefik
sudo ufw allow 3000/tcp   # Panel de Dokploy (solo temporal)

# Activar firewall
sudo ufw enable
sudo ufw status numbered

Importante: Docker puede saltarse reglas de UFW porque manipula iptables directamente. Si tu proveedor de cloud ofrece firewall integrado (como Cloud Firewall de DigitalOcean, Security Groups de AWS, etc.), te recomendamos configurarlo también como capa adicional de seguridad.

Configura las mismas reglas de firewall en el panel de tu proveedor:

22/TCP desde tu IP o rango de confianza (SSH)
80/TCP desde Anywhere (HTTP)
443/TCP desde Anywhere (HTTPS)
443/UDP desde Anywhere (HTTPS UDP)
3000/TCP temporalmente desde tu IP (solo para configuración inicial)

Paso 4: Instalar Dokploy

La instalación oficial de Dokploy es sencilla con su script:

curl -sSL https://dokploy.com/install.sh | sudo sh

Este script automáticamente:

Instala Docker si no está presente
Inicializa Docker Swarm
Crea la red overlay dokploy-network
Despliega servicios de Postgres, Redis y Dokploy
Levanta Traefik como reverse proxy
Publica el panel en el puerto 3000

Paso 5: Verificar la instalación

Comprueba que todo esté funcionando:

# Ver servicios de Docker Swarm
docker service ls

# Ver contenedores en ejecución
docker ps

# Verificar que los puertos estén escuchando
ss -lntup | grep -E '(:80|:443|:3000)'

Ahora abre tu navegador y accede al panel de Dokploy:

http://TU_IP_PUBLICA:3000

Completa el asistente inicial creando tu cuenta de administrador.

Paso 6: Configurar dominio y HTTPS (opcional pero recomendado)

Para acceder a tus aplicaciones con dominio propio y HTTPS:

En el panel de DNS de tu proveedor (Cloudflare, DigitalOcean, AWS Route53, etc.), añade tu dominio si no lo tienes ya.
Crea registros DNS:
- A record para @ apuntando a la IP de tu servidor
- A record para www apuntando a la IP de tu servidor
- O un subdominio como dokploy.tudominio.com

Espera la propagación DNS (puede tomar unos minutos).

Restringir acceso al puerto 3000

Por seguridad, una vez configurado Dokploy, restringe el acceso al puerto 3000:

En el firewall de tu proveedor de cloud, limítala solo a tu IP si necesitas acceso administrativo.

Paso 7: Desplegar tu primera aplicación "Hola Mundo" en Node.js

Vamos a crear una aplicación Node.js simple y desplegarla en Dokploy.

7.1 Crear el proyecto localmente

Crea una carpeta para tu proyecto y los siguientes archivos:

package.json:

{
  "name": "hola-mundo-dokploy",
  "version": "1.0.0",
  "description": "Aplicación Hola Mundo para Dokploy",
  "main": "app.js",
  "scripts": {
    "start": "node app.js"
  },
  "dependencies": {
    "express": "^4.18.2"
  }
}

app.js:

const express = require('express');
const app = express();
const PORT = 3000;

app.get('/', (req, res) => {
  res.json({
    message: '¡Hola Mundo desde Dokploy!',
    timestamp: new Date().toISOString(),
    environment: process.env.NODE_ENV
  });
});

app.get('/health', (req, res) => {
  res.status(200).send('OK');
});

app.listen(PORT, () => {
  console.log(`Servidor corriendo en puerto ${PORT}`);
});

Dockerfile:

FROM node:18-alpine
WORKDIR /app
COPY package*.json ./
RUN npm install --omit=dev
COPY . .
EXPOSE 3000
USER node
CMD ["node", "app.js"]

docker-compose.yml (para referencia):

version: '3.8'
services:
  app:
    build: .
    environment:
      - NODE_ENV=staging
    restart: unless-stopped

7.2 Desplegar en Dokploy

Despliegue parte 1

Despliegue parte 2

En el panel de Dokploy, haz clic en Create Project
Dale un nombre a tu proyecto (ej: "Tests")
En el panel de proyecto, haz click en Create Service y selecciona Application
Dale un nombre a tu aplicación: Hello World
Luego accede a tu aplicación y en la sección inferior Build Type selecciona Dockerfile y luego Save.
En la parte superior cuentas con la sección Provider. Para esta prueba seleccionaremos el tipo Drop, sin embargo para casos reales la mejor opción es a través de repositorio git.
Una vez seleccionado Drop, arrastra al área Zip file el zip con el código que especificamos en el punto 7.1.
Haz clic en el botón Deploy
Una vez terminado el despliegue, te mostrará la pestaña Deployments en la cual deberás ver un punto verde y Done que indica que el proceso fue exitoso. Puedes hacer clic en View para verificar el proceso.
Ahora, para desplegar nuestro Hola Mundo, ve a la pestaña Domains.
Para esta prueba usaremos un dominio gratuito de Traefik haciendo click en el icono de un par de dados, especificamos que el Container Port es 3000 y habilitamos el HTTPS con proveedor Let's Encrypt.
Luego haz clic en el botón Create
Al terminar nos dará una URL a la cual podremos ingresar y ver nuestra web. Importante: como estamos usando un dominio de prueba nos dará advertencia de seguridad. Para entornos de producción usa un dominio propio.

7.3 Verificar el despliegue

Una vez completado el despliegue, accede a tu aplicación:

https://tests-hello-world-puloud-d13d9c-167-172-as2dsaccc234-151.traefik.me/

Deberías ver el mensaje JSON de "Hola Mundo".

Paso 8: Buenas prácticas para producción

1. No compilar en el servidor de producción

Dokploy recomienda construir las imágenes Docker en CI/CD (GitHub Actions, GitLab CI) y luego desplegar la imagen ya construida. Esto ahorra recursos y reduce riesgo de downtime.

2. Usar health checks

Configura health checks en tus aplicaciones (como el endpoint /health en nuestro ejemplo) para que Docker Swarm pueda monitorear el estado.

3. Configurar backups

Configura backups regulares de tu servidor (si tu proveedor ofrece esta funcionalidad)
Configura backups de bases de datos regularmente
Usa docker volume para datos persistentes

4. Monitoreo y logs

# Ver logs de Dokploy
docker service logs dokploy --tail 100 -f

# Ver logs de tu aplicación
docker service logs hola-mundo_app --tail 100 -f

# Ver estado de los servicios
docker service ps hola-mundo_app

Conclusión

Dokploy ofrece una solución robusta y auto-hospedada para el despliegue de aplicaciones en Docker Swarm. Al implementarlo en un servidor Ubuntu, obtienes una infraestructura escalable, segura y profesional a un costo accesible.

¿Necesitas un servidor en la nube? Puedes obtener un Droplet Ubuntu en DigitalOcean usando nuestro enlace de referido y recibir créditos iniciales para probar este tutorial.

Recursos adicionales

¿Te gustó este tutorial? Comparte tus experiencias desplegando aplicaciones con Dokploy en los comentarios o sugiere temas para futuros artículos.

Basic Load Balancing for a Web System on DigitalOcean

Oscar Ricardo Sánche Gutierréz — Fri, 06 Mar 2026 20:43:27 +0000

In this article we’ll build a simple and inexpensive load-balanced web setup on DigitalOcean.

The architecture is intentionally minimal:

1 DigitalOcean Load Balancer
2 small droplets
A lightweight web app running with Docker + PHP + Nginx

The goal is to show how quickly you can build a basic scalable web entry point without complex infrastructure.

Architecture diagram created with savnet.co:

Creating the first server

Go to your DigitalOcean account and create a small droplet.

Configuration used in this guide:

Image: Docker latest on Ubuntu 22.04
Region: choose the closest to your users
Authentication: SSH recommended (Password also works)
Hostname: WebServer-1

Once the droplet is ready, connect to the server.

Preparing the server

1. Create a user

adduser web_app
usermod -aG sudo web_app
sudo usermod -aG docker web_app
su - web_app

This user will run the application and manage Docker.

2. Create the application folder

mkdir -p ~/app
cd ~/app

3. Create the application files

`index.php`

A very small script that prints the server IP responding to the request.

<?php

echo 'Hi. From ip '.$_SERVER['SERVER_ADDR'];

`nginx.conf`

Basic Nginx configuration to serve PHP via PHP-FPM.

server {
    listen 80;
    server_name localhost;
    root /var/www/html;
    index index.php;

    location / {
        try_files $uri $uri/ =404;
    }

    location ~ \.php$ {
        fastcgi_pass 127.0.0.1:9000;
        fastcgi_index index.php;
        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
        include fastcgi_params;
    }
}

`docker-compose.yml`

This setup runs Nginx + PHP-FPM using Docker.

version: '3.8'

services:
  nginx:
    image: nginx:alpine
    container_name: nginx-web
    network_mode: host
    volumes:
      - ./:/var/www/html
      - ./nginx.conf:/etc/nginx/conf.d/default.conf
    depends_on:
      - php-fpm

  php-fpm:
    image: php:8.2-fpm
    container_name: php-app
    network_mode: host
    volumes:
      - ./:/var/www/html

4. Start the application

Run:

docker compose up

If everything is correct you should see the containers starting.

Open the server IP in your browser.

You should see something like:

Hi. From ip 10.x.x.x

Creating the Load Balancer

Now we create the DigitalOcean Load Balancer.

Configure:

HTTP forwarding
Attach WebServer-1

Once created, open the load balancer IP.

You’ll see something similar to this:

Notice that the response shows an internal server IP, because traffic between the load balancer and droplets happens inside DigitalOcean’s network.

Creating the second server faster

Instead of repeating the setup manually, we can create a snapshot of the first droplet.

Then create a new droplet from that snapshot in the same region.

Adding the new node to the Load Balancer

Go back to the Load Balancer configuration and attach the second server.

After about a minute, DigitalOcean will mark the droplet as healthy.

Now refresh the Load Balancer IP multiple times.

You should see responses coming from different internal IPs, meaning traffic is being distributed.

Security recommendations

This example focuses on the basic load balancing setup, but in a real environment you should also:

Add a DigitalOcean firewall
Restrict droplets so they are only reachable from the load balancer
Enable HTTPS
Configure health checks

These small changes significantly improve the security of the system.

Tools used

OBS – screen recording
Kdenlive – video editing
savnet.co – architecture diagrams used in this article