---
title: "Cómo conectarse a un servidor Linux por SSH con claves"
description: "Conéctate a tu servidor Linux por SSH desde Linux, macOS o Windows, verifica la huella del host, crea una clave Ed25519 y usa alias en ~/.ssh/config."
category: "Configuración del Servidor"
language: es
source: https://cubepath.com/es/docs/configuración-del-servidor/como-conectar-a-tu-servidor-via-ssh
updated: 2026-09-25
---

# Cómo conectarse a un servidor Linux por SSH con claves

SSH (Secure Shell) es el protocolo estándar para administrar servidores Linux de forma remota: cifra la sesión completa y permite autenticarse con contraseña o, mucho mejor, con un par de claves. En esta guía te conectarás por primera vez a un servidor con Ubuntu 24.04, crearás una clave Ed25519, la instalarás en el servidor y configurarás un alias en `~/.ssh/config` para conectarte con un solo comando desde Linux, macOS o Windows.

## Requisitos previos

- Un servidor Linux con el servicio SSH activo, por ejemplo un VPS de CubePath con Ubuntu 24.04. Las instrucciones sirven igual para Debian 12 y Rocky Linux 9.
- La dirección IP pública del servidor (`your_server_ip`) y el usuario inicial con su contraseña o la clave que elegiste al crearlo.
- Un equipo local con Linux, macOS o Windows 10/11. Los tres incluyen el cliente OpenSSH.

## Paso 1: Comprobar el cliente SSH en tu equipo

Linux y macOS traen el cliente `ssh` instalado. En Windows 10 y 11 viene como característica opcional activada por defecto y funciona desde PowerShell o Windows Terminal. Comprueba la versión:

```bash
ssh -V
```

```output
OpenSSH_9.6p1 Ubuntu-3ubuntu13, OpenSSL 3.0.13 30 Jan 2024
```

La versión exacta varía según el sistema. Si en Windows el comando no existe, instálalo desde PowerShell como administrador:

```powershell
Add-WindowsCapability -Online -Name OpenSSH.Client~~~~0.0.1.0
```

En una distribución Linux mínima sin cliente, instálalo con `sudo apt install openssh-client` (Debian/Ubuntu) o `sudo dnf install openssh-clients` (Rocky/RHEL).

## Paso 2: Conectarte por primera vez

La sintaxis básica es `ssh usuario@servidor`. Sustituye `root` por el usuario inicial de tu servidor y `your_server_ip` por su IP:

```bash
ssh root@your_server_ip
```

En la primera conexión el cliente no conoce el servidor y te muestra su huella digital:

```output
The authenticity of host 'your_server_ip (your_server_ip)' can't be established.
ED25519 key fingerprint is SHA256:Vb3mP0qZ1pQ8f5bX2c7n4H9yKkLw6tR0aJ1sE8dUu2c.
This key is not known by any other names.
Are you sure you want to continue connecting (yes/no/[fingerprint])?
```

Esa huella identifica al servidor. Si quieres asegurarte de que no hay nadie en medio, compárala con la que muestra el propio servidor desde la consola del panel de CubePath:

```bash
ssh-keygen -lf /etc/ssh/ssh_host_ed25519_key.pub
```

Escribe `yes`. El cliente guarda la huella en `~/.ssh/known_hosts` y en las siguientes conexiones solo avisará si cambia. Después introduce la contraseña (no se muestra al escribirla) y verás el prompt del servidor:

```output
Welcome to Ubuntu 24.04.3 LTS (GNU/Linux 6.8.0-85-generic x86_64)
...
root@your_hostname:~#
```

Para salir escribe `exit` o pulsa `Ctrl+D`. Si el servidor escucha en otro puerto, indícalo con `-p`:

```bash
ssh -p 2222 root@your_server_ip
```

## Paso 3: Crear un par de claves SSH

La autenticación con claves es más segura que la contraseña y permite desactivar después el acceso por contraseña. Genera una clave Ed25519 en tu equipo local, no en el servidor:

```bash
ssh-keygen -t ed25519 -C "tu_correo@example.com"
```

Pulsa Enter para aceptar la ruta por defecto (`~/.ssh/id_ed25519`) y escribe una frase de paso. La frase cifra la clave privada en disco: si alguien copia el archivo, no podrá usarlo sin ella.

```output
Your identification has been saved in /home/your_user/.ssh/id_ed25519
Your public key has been saved in /home/your_user/.ssh/id_ed25519.pub
```

Se crean dos archivos:

| Archivo | Contenido | Se comparte |
|---|---|---|
| `~/.ssh/id_ed25519` | Clave privada | Nunca |
| `~/.ssh/id_ed25519.pub` | Clave pública | Sí, se copia a los servidores |

> Nota: si el servidor o una herramienta antigua no admite Ed25519, usa `ssh-keygen -t rsa -b 4096`. Hoy en día es raro necesitarlo.

## Paso 4: Copiar la clave pública al servidor

La clave pública debe añadirse al archivo `~/.ssh/authorized_keys` del usuario con el que te conectas. En Linux y macOS, `ssh-copy-id` lo hace por ti y ajusta los permisos:

```bash
ssh-copy-id root@your_server_ip
```

```output
Number of key(s) added: 1

Now try logging into the machine, with:   "ssh 'root@your_server_ip'"
and check to make sure that only the key(s) you wanted were added.
```

Windows no incluye `ssh-copy-id`. Desde PowerShell puedes enviar la clave con un solo comando:

```powershell
type $env:USERPROFILE\.ssh\id_ed25519.pub | ssh root@your_server_ip "mkdir -p ~/.ssh && chmod 700 ~/.ssh && cat >> ~/.ssh/authorized_keys && chmod 600 ~/.ssh/authorized_keys"
```

Vuelve a conectarte. Esta vez el servidor no pedirá la contraseña del usuario, solo la frase de paso de tu clave (si la pusiste):

```bash
ssh root@your_server_ip
```

Para confirmar qué método se ha usado, conéctate en modo detallado y busca la línea de autenticación:

```bash
ssh -v root@your_server_ip exit 2>&1 | grep "Authenticated"
```

```output
Authenticated to your_server_ip ([your_server_ip]:22) using "publickey".
```

## Paso 5: Evitar escribir la frase de paso con ssh-agent

El agente SSH mantiene la clave descifrada en memoria durante la sesión. En la mayoría de escritorios Linux y en macOS ya está en marcha; añade la clave con:

```bash
ssh-add ~/.ssh/id_ed25519
```

En macOS puedes guardar la frase en el llavero con `ssh-add --apple-use-keychain ~/.ssh/id_ed25519`. En Windows, activa el servicio del agente una vez desde PowerShell como administrador y añade la clave:

```powershell
Get-Service ssh-agent | Set-Service -StartupType Automatic
Start-Service ssh-agent
ssh-add $env:USERPROFILE\.ssh\id_ed25519
```

Comprueba las claves cargadas con `ssh-add -l`.

## Paso 6: Crear un alias en ~/.ssh/config

Si gestionas varios servidores, el archivo de configuración del cliente evita recordar IPs, usuarios y puertos. Créalo o edítalo en tu equipo local (en Windows está en `C:\Users\tu_usuario\.ssh\config`):

```bash
nano ~/.ssh/config
```

Añade un bloque por servidor:

```text
Host mi-vps
    HostName your_server_ip
    User your_user
    Port 22
    IdentityFile ~/.ssh/id_ed25519
    IdentitiesOnly yes
    ServerAliveInterval 60
```

`IdentitiesOnly yes` hace que se ofrezca solo esa clave, lo que evita errores de "Too many authentication failures" cuando tienes muchas claves en el agente. `ServerAliveInterval` envía un paquete cada 60 segundos para que la sesión no se corte por inactividad. En Linux y macOS el archivo debe ser privado:

```bash
chmod 600 ~/.ssh/config
```

Ahora te conectas con el alias, y también funciona con `scp` y `rsync`:

```bash
ssh mi-vps
scp archivo.tar.gz mi-vps:/tmp/
```

## Paso 7: Ejecutar comandos y abrir túneles

No siempre necesitas una sesión interactiva. Puedes ejecutar un comando remoto y volver a tu terminal:

```bash
ssh mi-vps "uptime && df -h /"
```

Un túnel local sirve para llegar a un servicio que solo escucha en `localhost` del servidor, como un panel de administración o una base de datos. Este ejemplo publica en tu puerto local 8080 el puerto 80 del servidor, sin abrirlo en el firewall:

```bash
ssh -N -L 8080:localhost:80 mi-vps
```

Mientras el comando siga activo, abre `http://localhost:8080` en tu navegador. Pulsa `Ctrl+C` para cerrar el túnel.

## Solución de problemas

**`Connection timed out`**: el paquete no llega al servidor. Comprueba la IP, que el servidor esté encendido y que el firewall permita el puerto SSH. Prueba el puerto desde tu equipo con `nc -vz your_server_ip 22`.

**`Connection refused`**: el servidor responde pero nada escucha en ese puerto. Entra por la consola del panel y revisa el servicio con `sudo systemctl status ssh` (en Rocky Linux, `sshd`) y el puerto real con `sudo ss -tlnp | grep ssh`.

**`Permission denied (publickey)`**: el servidor no acepta tu clave. Revisa que te conectas con el usuario correcto y que los permisos en el servidor son estrictos, ya que OpenSSH ignora `authorized_keys` si otros usuarios pueden escribir en él:

```bash
chmod 700 ~/.ssh
chmod 600 ~/.ssh/authorized_keys
```

En el servidor, `sudo journalctl -u ssh -n 20` muestra el motivo exacto del rechazo.

**`WARNING: REMOTE HOST IDENTIFICATION HAS CHANGED!`**: la clave del servidor no coincide con la guardada. Es normal si reinstalaste el servidor con la misma IP; en ese caso borra la entrada antigua y vuelve a verificar la huella:

```bash
ssh-keygen -R your_server_ip
```

Si no has reinstalado nada, no continúes e investiga antes de conectarte.

## Conclusión

Ya te conectas a tu servidor con una clave Ed25519 protegida por frase de paso y un alias en `~/.ssh/config`. El siguiente paso lógico es crear un usuario con `sudo`, desactivar el acceso por contraseña y el login de root, y activar un firewall, tal como se explica en la guía de configuración inicial de seguridad en Ubuntu/Debian. También puedes cambiar el puerto SSH por defecto para reducir el ruido de los escaneos automáticos.