---
title: "Cómo instalar Teleport en Ubuntu 24.04 para acceso SSH"
description: "Instala Teleport en Ubuntu 24.04 con HTTPS automático, crea usuarios y roles, añade servidores SSH con certificados de corta duración y revisa sesiones."
category: "Herramientas de Seguridad"
language: es
source: https://cubepath.com/es/docs/herramientas-de-seguridad/teleport-acceso-seguro-a-infraestructura
updated: 2026-09-25
---

# Cómo instalar Teleport en Ubuntu 24.04 para acceso SSH

Teleport es una plataforma de acceso a infraestructura que sustituye las claves SSH estáticas por certificados de corta duración emitidos tras un inicio de sesión con segundo factor, y que registra y graba cada sesión. En este tutorial instalarás un clúster de Teleport en Ubuntu 24.04 con certificado TLS de Let's Encrypt, crearás un usuario administrador, añadirás un segundo servidor como nodo SSH y limitarás el acceso con un rol. Al terminar entrarás a tus servidores con `tsh ssh` y podrás reproducir cualquier sesión desde el panel web.

## Requisitos previos

Para seguir esta guía necesitas:

- Un servidor con Ubuntu 24.04 LTS para el clúster de Teleport (Auth Service y Proxy Service), por ejemplo un VPS de CubePath, con al menos 2 GB de RAM.
- Un segundo servidor Linux que quieras gestionar como nodo SSH.
- Un usuario no root con privilegios `sudo` en ambos.
- Un dominio con un registro A que apunte a la IP pública del servidor de Teleport. En la guía se usa `teleport.your_domain`.
- El puerto 443/TCP abierto en el servidor de Teleport. Los nodos solo necesitan salida hacia ese puerto.
- Una aplicación de autenticación (TOTP) o una llave de seguridad para el segundo factor, que Teleport exige por defecto.

> Nota: desde la versión 16, Teleport Community Edition es gratuita para uso comercial solo en organizaciones de menos de 100 empleados y menos de 10 millones de dólares de facturación anual. Revisa la licencia antes de usarla en producción.

## Paso 1: Instalar Teleport desde el repositorio oficial

Teleport publica un repositorio APT por versión mayor. Consulta la versión mayor actual en la [página de descargas de Teleport](https://goteleport.com/download/) y guárdala en una variable; en este ejemplo es la 18:

```bash
TELEPORT_MAJOR=18
```

Descarga la clave de firma del repositorio en `/etc/apt/keyrings`:

```bash
sudo install -m 0755 -d /etc/apt/keyrings
sudo curl -fsSL https://apt.releases.teleport.dev/gpg -o /etc/apt/keyrings/teleport-archive-keyring.asc
```

Añade el repositorio usando el identificador y el nombre en clave de tu distribución, que se leen de `/etc/os-release`:

```bash
. /etc/os-release
echo "deb [signed-by=/etc/apt/keyrings/teleport-archive-keyring.asc] https://apt.releases.teleport.dev/${ID} ${VERSION_CODENAME} stable/v${TELEPORT_MAJOR}" | sudo tee /etc/apt/sources.list.d/teleport.list
```

Instala el paquete:

```bash
sudo apt update
sudo apt install teleport
```

Comprueba la versión instalada:

```bash
teleport version
```

```output
Teleport v18.x.x git:v18.x.x go1.24.x
```

El paquete incluye el servicio `teleport`, la herramienta de administración `tctl` y el cliente `tsh`.

## Paso 2: Configurar el clúster con HTTPS automático

Genera el archivo `/etc/teleport.yaml` con `teleport configure`. La opción `--acme` hace que el Proxy Service obtenga y renueve el certificado de Let's Encrypt por sí mismo mediante el puerto 443, así que el registro DNS debe estar ya propagado. Sustituye `teleport.your_domain` y `admin@your_domain`:

```bash
sudo teleport configure -o file \
  --acme --acme-email=admin@your_domain \
  --cluster-name=teleport.your_domain
```

```output
A Teleport configuration file has been created at "/etc/teleport.yaml".
```

Abre el puerto 443 en UFW sin perder el acceso SSH actual:

```bash
sudo ufw allow OpenSSH
sudo ufw allow 443/tcp
sudo ufw enable
```

Habilita y arranca el servicio:

```bash
sudo systemctl enable --now teleport
```

Revisa el estado y, si algo falla, el log del servicio:

```bash
sudo systemctl status teleport --no-pager
sudo journalctl -u teleport -n 50 --no-pager
```

Desde tu equipo, comprueba que el Proxy responde con un certificado válido:

```bash
curl https://teleport.your_domain/webapi/ping
```

La respuesta es un JSON que incluye el nombre del clúster y la versión del servidor. Si `curl` se queja del certificado, espera un minuto a que Teleport termine de obtenerlo y vuelve a intentarlo.

## Paso 3: Crear el usuario administrador

Crea un usuario con los roles predefinidos `editor` (administración del clúster) y `access` (acceso a recursos). La opción `--logins` define con qué usuarios del sistema operativo podrá entrar en los servidores; sustituye `your_user` por el tuyo:

```bash
sudo tctl users add teleport-admin --roles=editor,access --logins=root,your_user
```

```output
User "teleport-admin" has been created but requires a password. Share this URL with the user to complete user setup, link is valid for 1h:
https://teleport.your_domain:443/web/invite/0123456789abcdef

NOTE: Make sure teleport.your_domain:443 points at a Teleport proxy which users can access.
```

Abre el enlace en el navegador, elige una contraseña y registra tu segundo factor. Después podrás entrar en `https://teleport.your_domain` y verás el propio servidor de Teleport en la lista de recursos, porque `teleport configure` también activa el servicio SSH en él.

## Paso 4: Iniciar sesión con tsh

`tsh` es el cliente de línea de comandos. En Linux se instala con el mismo paquete `teleport`; en macOS y Windows descárgalo desde la página de descargas de Teleport. Inicia sesión desde tu equipo:

```bash
tsh login --proxy=teleport.your_domain --user=teleport-admin
```

Tras la contraseña y el segundo factor, `tsh` guarda un certificado válido durante unas horas:

```output
> Profile URL:        https://teleport.your_domain:443
  Logged in as:       teleport-admin
  Cluster:            teleport.your_domain
  Roles:              access, editor
  Logins:             root, your_user
  Valid until:        2026-09-25 22:14:03 +0200 CEST [valid for 12h0m0s]
```

Lista los servidores disponibles y conéctate a uno:

```bash
tsh ls
tsh ssh your_user@teleport
```

El nombre que aparece en la columna `Node Name` de `tsh ls` es el que usas con `tsh ssh`.

## Paso 5: Añadir un servidor como nodo SSH

Cada servidor que quieras gestionar ejecuta Teleport con solo el servicio SSH activo y se une al clúster con un token de un solo uso. En el servidor de Teleport, genera un token válido durante una hora:

```bash
sudo tctl tokens add --type=node --ttl=1h
```

```output
The invite token: 7a4c3e0d9b8f1a2e6c5d4b3a29180716
This token will expire in 60 minutes.
```

En el nuevo servidor, instala Teleport repitiendo el paso 1. Después genera su configuración apuntando al Proxy con el token anterior:

```bash
sudo teleport node configure \
  --output=file:///etc/teleport.yaml \
  --token=7a4c3e0d9b8f1a2e6c5d4b3a29180716 \
  --proxy=teleport.your_domain:443
```

Añade etiquetas al nodo para poder filtrarlo en los roles. Edita el archivo:

```bash
sudo nano /etc/teleport.yaml
```

Dentro de la sección `ssh_service`, añade un bloque `labels`:

```yaml
ssh_service:
  enabled: true
  labels:
    env: staging
```

Arranca el servicio:

```bash
sudo systemctl enable --now teleport
```

El nodo abre una conexión saliente hacia el Proxy, así que no hace falta abrir ningún puerto de entrada en él. Desde tu equipo, comprueba que aparece:

```bash
tsh ls
```

```output
Node Name Address        Labels
--------- -------------- ----------------------------------
teleport  ⟵ Tunnel       hostname=teleport
web01     ⟵ Tunnel       env=staging,hostname=web01
```

Cuando confirmes que entras por Teleport, puedes cerrar el puerto 22 del nodo hacia Internet.

## Paso 6: Limitar el acceso con un rol

Los roles definen con qué usuarios del sistema y en qué servidores puede entrar cada persona. Crea un rol para desarrolladores que solo permita entrar como `your_user` en servidores con la etiqueta `env: staging`:

```bash
nano developer.yaml
```

```yaml
kind: role
version: v7
metadata:
  name: developer
spec:
  allow:
    logins: ['your_user']
    node_labels:
      env: ['staging']
  options:
    max_session_ttl: 8h
```

Carga el rol en el clúster y crea un usuario con él:

```bash
sudo tctl create -f developer.yaml
sudo tctl users add alice --roles=developer
```

Alice recibirá su propio enlace de invitación. Cuando inicie sesión con `tsh login`, `tsh ls` solo le mostrará `web01`, y su certificado caducará como máximo a las 8 horas.

## Paso 7: Revisar el registro de auditoría y las sesiones grabadas

Teleport graba por defecto las sesiones SSH interactivas y registra eventos como inicios de sesión, comandos `tctl` y conexiones. Lista las grabaciones desde tu equipo:

```bash
tsh recordings ls
```

Reproduce una sesión en la terminal con su identificador:

```bash
tsh play <session_id>
```

En el panel web encontrarás lo mismo en **Audit > Session Recordings** y **Audit > Audit Log**, con filtros por usuario, fecha y tipo de evento.

## Solución de problemas

**El navegador muestra un error de certificado.** Revisa `sudo journalctl -u teleport` en busca de errores ACME. Las causas habituales son que el registro A aún no apunta al servidor o que el puerto 443 está bloqueado por un firewall externo.

**`tctl tokens add` o el nodo fallan con token expirado.** Los tokens duran lo indicado en `--ttl`. Genera uno nuevo, actualiza `join_params.token_name` en `/etc/teleport.yaml` del nodo y reinicia con `sudo systemctl restart teleport`.

**`tsh ssh` devuelve `access denied`.** El usuario del sistema que usas no está en `logins` del rol, o el nodo no tiene las etiquetas que el rol permite. Comprueba tus logins con `tsh status` y las etiquetas del nodo con `tsh ls`. Recuerda que el usuario debe existir en el servidor de destino.

## Conclusión

Has desplegado un clúster de Teleport con HTTPS automático, has añadido un servidor como nodo SSH que se conecta por túnel inverso y has limitado el acceso con un rol basado en etiquetas, todo con certificados de corta duración y sesiones grabadas. Como siguientes pasos puedes conectar un proveedor de identidad (GitHub en Community Edition) para no gestionar contraseñas, añadir un clúster de Kubernetes o una base de datos al mismo Proxy y enviar el registro de auditoría a almacenamiento externo.