> For the complete documentation index, see [llms.txt](https://es-kb.topopool.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://es-kb.topopool.com/primeros-pasos/preparacion.md).

# Preparando el servidor

## Requisitos de hardware

Antes de empezar, asegurémonos de que el servidor cumple con lo mínimo necesario para correr un nodo de Cardano de forma estable:

| Componente     | Mínimo recomendado           |
| -------------- | ---------------------------- |
| CPU            | 2 núcleos (4 recomendado)    |
| RAM            | 16 GB (ver nota abajo)       |
| Almacenamiento | 300 GB SSD (NVMe preferible) |
| OS             | Ubuntu 22.04 LTS o 24.04 LTS |

{% hint style="info" %}
**Sobre la RAM según el modo UTxO-HD:**

* **OnDisk / LSM** (recomendado, modo por defecto desde cardano-node 10.7): con 8 GB puede funcionar, aunque 16 GB es más cómodo para tener margen.
* **InMemory**: necesitás al menos 24 GB. Este modo mantiene todo el estado en RAM y es considerablemente más exigente.

Si no sabés cuál vas a usar, quedáte con 16 GB como mínimo y usá el modo OnDisk — es el que recomendamos.
{% endhint %}

## Actualizar el sistema

Lo primero siempre es traer el sistema al día:

```bash
sudo apt-get update -y
sudo apt-get upgrade -y
sudo apt-get autoremove -y
```

{% hint style="info" %}
Si el servidor pide reiniciar después de las actualizaciones, hacelo antes de seguir. Es especialmente importante si se actualizó el kernel.
{% endhint %}

## Instalar dependencias

Instalamos todas las bibliotecas y herramientas que necesita cardano-node para compilar correctamente. A partir de la versión 11.x se agregan tres nuevas dependencias para el backend LSM: `liburing-dev`, `libsnappy-dev` y `protobuf-compiler`:

```bash
sudo apt-get install -y \
  automake build-essential pkg-config libffi-dev libgmp-dev libssl-dev \
  libncurses-dev libsystemd-dev zlib1g-dev make g++ tmux git jq wget \
  libtool autoconf liblmdb-dev libsnappy-dev protobuf-compiler liburing-dev \
  curl htop nano screen net-tools
```

## Configurar el firewall

Este paso es opcional pero muy recomendable. La idea es dejar pasar únicamente el tráfico que necesitamos y bloquear todo lo demás.

Tenemos dos opciones: `iptables` (más control, más verboso) o `ufw` (más simple, ideal si no tenés un esquema complejo).

### Opción A: UFW (más simple)

```bash
sudo ufw default deny incoming
sudo ufw default allow outgoing
sudo ufw allow 22/tcp          # SSH
sudo ufw allow 3001/tcp        # cardano-node relay
sudo ufw allow from <ip_grafana> to any port 12798
sudo ufw allow from <ip_grafana> to any port 9001
sudo ufw enable
sudo ufw status verbose
```

### Opción B: iptables

```bash
sudo iptables -F

sudo iptables -A INPUT -m state --state RELATED,ESTABLISHED -j ACCEPT
sudo iptables -A INPUT -i lo -j ACCEPT
sudo iptables -A INPUT -p icmp -s <ip_otros_nodos> -j ACCEPT
sudo iptables -A INPUT -p tcp -m state --state NEW -m tcp --dport 22 -j ACCEPT
sudo iptables -A INPUT -p tcp -m state --state NEW -m tcp --dport 3001 -j ACCEPT
sudo iptables -A INPUT -p tcp -m state --state NEW -m tcp -s <ip_grafana> --dport 12798 -j ACCEPT
sudo iptables -A INPUT -p tcp -m state --state NEW -m tcp -s <ip_grafana> --dport 9001 -j ACCEPT
sudo iptables -A INPUT -j REJECT --reject-with icmp-host-prohibited

sudo /sbin/iptables-save
```

Para aplicar cambios de forma segura (se revierten solos en 60 segundos si algo sale mal), editá `/etc/iptables/rules.v4` directamente y luego:

```bash
sudo iptables-apply -t 60 /etc/iptables/rules.v4
```

{% hint style="danger" %}
**Importante antes de aplicar cualquier regla de firewall:**

Siempre verificá que el puerto SSH esté incluido en las reglas de entrada. Si lo bloqueás sin querer, perdés el acceso al servidor.

Además, SSH debería estar asegurado con llaves RSA, autenticación de doble factor, puerto personalizado o una combinación de estas. Un pool con SSH débil es un riesgo real para tu pledge.
{% endhint %}

## Ajustes adicionales recomendados

Vale la pena revisar estos puntos antes de seguir:

* **Swap**: si tu servidor tiene el mínimo de RAM, tener swap evita que el proceso muera en momentos de pico.
* **Swappiness**: reducirlo (por ejemplo a `10`) hace que el kernel prefiera RAM antes de recurrir al swap.
* **Cache Pressure**: ajustarlo a `50` o menos reduce la presión sobre la caché de inodos y directorios.

Podés guiarte con [este artículo de Digital Ocean](https://do.co/3j0CPSD) que lo explica paso a paso.