Práctica 1.7: Acceso ssh a github

P7 - Autenticación SSH con Git y GitHub

En P4 conectaste un proyecto con GitHub por HTTPS. Aquí configurarás una clave SSH para autenticarte de forma segura con GitHub. La clave pública se comparte con GitHub; la privada nunca se comparte ni se sube al repositorio.

La clave privada estará protegida mediante una frase de paso. Para evitar tener que introducirla repetidamente durante el trabajo, podrás utilizar ssh-agent, que mantiene temporalmente disponible la clave después de desbloquearla.

También aprenderás a utilizar SSH mediante el puerto 443 cuando una red bloquee el puerto 22, utilizado normalmente por SSH.

1. Objetivos

• Comprobar si existe una clave SSH y generar una ed25519 si hace falta.
• Proteger la clave privada mediante una frase de paso.
• Comprender para qué se utiliza ssh-agent.
• Registrar la clave pública en GitHub y verificar la conexión.
• Utilizar SSH mediante el puerto 443 si la red bloquea el puerto 22.
• Cambiar el remoto de un repositorio de HTTPS a SSH.

2. Relación con RA y criterios de evaluación

Esta práctica apoya el RA1 mediante el trabajo con el proyecto creado en el IDE y su repositorio. SSH y GitHub son herramientas instrumentales: no se les atribuye un resultado de aprendizaje ni criterios distintos de los que se trabajan realmente.

Código	Descripción
RA1	Reconoce la estructura de un programa informático, identificando y relacionando los elementos propios del lenguaje de programación utilizado.
CE b	Se han creado proyectos de desarrollo de aplicaciones.
CE c	Se han utilizado entornos integrados de desarrollo.

3. Requisitos y recursos

• Haber completado la P4 y disponer de un repositorio de prueba con un remoto de GitHub configurado mediante HTTPS.
• Una cuenta de GitHub a la que puedas añadir una clave SSH y acceso a una terminal: Git Bash en Windows, PowerShell, o el terminal de Linux o macOS.
• Git y OpenSSH instalados. El comando ssh -V permite comprobar que SSH está disponible.
• Consulta, si necesitas repasar el punto de partida, la P4. Ramas, stash y GitHub y la documentación de GitHub sobre la autenticación SSH.

4. Pasos a seguir

4.1. Comprobar o generar la clave

1. Abre una terminal (Git Bash en Windows) y lista el contenido de .ssh:

   ls -al ~/.ssh
   

   Si existe id_ed25519.pub o una clave con otro nombre, puedes reutilizarla.

   En los pasos siguientes sustituye ~/.ssh/id_ed25519 por la ruta de esa clave cuando tenga otro nombre.

2. Si no existe una clave, genera una nueva con un comentario neutro (utiliza el correo del "iesrafaelalberti", que debería ser el correo primario de tu cuenta de GitHub):

   ssh-keygen -t ed25519 -C "tu-correo@example.com"
   

   Acepta la ruta propuesta o elige una ruta propia.

   Al crear la clave, puedes establecer una frase de paso para proteger la clave privada:

   • En tu equipo personal, puedes dejar la frase de paso vacía para simplificar su uso. Pulsa Enter cuando se solicite y vuelve a pulsar Enter para confirmarlo.
   • En un equipo público o compartido, establece una frase de paso. De esta forma, la clave privada no podrá utilizarse directamente sin conocerla.

   Si utilizas una frase de paso, más adelante veremos cómo ssh-agent permite introducirla una sola vez durante la sesión de trabajo.

   Nunca compartas la clave privada.

   Comparte únicamente el archivo .pub. No publiques ni envíes id_ed25519, capturas donde se vea su contenido o una frase de paso.

4.2. Registrar la clave pública en GitHub

Al generar la clave SSH se han creado dos archivos:

~/.ssh/id_ed25519       → clave privada
~/.ssh/id_ed25519.pub   → clave pública

La clave privada permanece siempre en tu equipo y está protegida mediante la frase de paso que estableciste al crearla.

La clave pública es la que vamos a registrar en GitHub.

1. Muestra el contenido de la clave pública:

   cat ~/.ssh/id_ed25519.pub
   

   En PowerShell puedes utilizar:

   Get-Content $HOME\.ssh\id_ed25519.pub
   

2. El contenido completo de id_ed25519.pub tendrá un aspecto similar a este y estará en una sola línea:

   ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAA...tu_clave_aquí... tu_email@ejemplo.com
   

3. Copia la línea completa y ve a:

   GitHub > Settings > SSH and GPG keys > New SSH key

   Pon un título que permita identificar el equipo, pega la clave pública y confirma.

A partir de este momento, GitHub conoce tu clave pública, mientras que la clave privada continúa únicamente en tu equipo.

4.3. Verificar la conexión SSH

Una vez registrada la clave pública, comprueba la conexión con GitHub:

ssh -T git@github.com

Este comando solo realiza una prueba utilizando el puerto por defecto para SSH, que será el 22.

La primera vez que te conectes desde ese equipo, SSH puede mostrar un mensaje preguntando si confías en la identidad del servidor. Una vez aceptada, quedará registrada en el equipo.

Si tu clave privada está protegida mediante una frase de paso, SSH puede solicitarla para poder utilizarla:

Enter passphrase for key '/c/Users/.../.ssh/id_ed25519':

Si la autenticación se realiza correctamente, GitHub mostrará un mensaje indicando que te has autenticado correctamente y que GitHub no proporciona acceso a una shell.

En este momento ya tienes funcionando la autenticación SSH:

Tu equipo                              GitHub

clave privada                         clave pública
id_ed25519                            registrada
     │                                     │
     └────── autenticación SSH ───────────►│

La clave privada nunca se envía a GitHub. GitHub utiliza la clave pública registrada para comprobar que estás utilizando la clave privada correspondiente.

Si la conexión no se realiza correctamente, o posteriormente tienes problemas al utilizar SSH con operaciones como git clone, git pull o git push, es posible que la red esté bloqueando el puerto 22 utilizado normalmente por SSH. En ese caso, continúa con el apartado 4.4, donde aprenderás a comprobar la conexión y configurar SSH mediante el puerto 443.

4.4. Utilizar SSH si el puerto 22 está bloqueado

Cuando Git encuentra una dirección como:

git@github.com:TU_USUARIO/TU_REPOSITORIO.git

sabe que debe utilizar SSH para comunicarse con GitHub.

Por ejemplo, al ejecutar:

git clone git@github.com:TU_USUARIO/TU_REPOSITORIO.git

ocurre, de forma simplificada:

Git reconoce que debe utilizar SSH
            ↓
Git utiliza el cliente SSH del equipo
            ↓
SSH consulta su configuración (~/.ssh/config)
            ↓
SSH establece la conexión con GitHub

Por tanto, Git decide utilizar SSH, pero es SSH quien se encarga de establecer la conexión y determina aspectos como el servidor, el puerto o la clave que debe utilizar.

Por defecto, SSH intenta conectarse a GitHub mediante el puerto 22. Esto mismo ocurrirá posteriormente con git pull, git fetch o git push.

¿Qué ocurre si la red bloquea el puerto 22?

Algunas redes públicas, educativas o corporativas bloquean este puerto. GitHub permite utilizar alternativamente el puerto 443.

Primero podemos comprobar si funciona:

ssh -T -p 443 git@ssh.github.com

Este comando solo realiza una prueba utilizando el puerto 443. No modifica la configuración de SSH para futuras conexiones.

Si la conexión funciona, crea o edita el archivo:

~/.ssh/config

y añade:

Host github.com
    HostName ssh.github.com
    User git
    Port 443

A partir de ese momento, cuando SSH reciba una conexión dirigida a:

github.com

consultará ~/.ssh/config y realmente se conectará a:

ssh.github.com:443

Por eso podemos seguir utilizando normalmente:

ssh -T git@github.com

y las direcciones habituales de los repositorios:

git@github.com:TU_USUARIO/TU_REPOSITORIO.git

Por ejemplo:

git clone git@github.com:TU_USUARIO/TU_REPOSITORIO.git

Git seguirá indicando que quiere utilizar SSH con github.com, pero SSH aplicará automáticamente la configuración del archivo ~/.ssh/config y realizará la conexión mediante el puerto 443.

4.5. Evitar introducir continuamente la frase de paso: ssh-agent

La conexión SSH ya funciona, pero hay una pequeña incomodidad: cuando SSH necesita utilizar nuestra clave privada puede solicitar su frase de paso.

Podríamos trabajar así sin ningún problema. Por ejemplo:

git push
    ↓
SSH necesita la clave privada
    ↓
introducimos la frase de paso
    ↓
GitHub verifica nuestra identidad

Si no queremos introducir la frase de paso repetidamente durante una sesión de trabajo podemos utilizar ssh-agent.

ssh-agent es un programa que mantiene temporalmente disponible nuestra clave privada después de desbloquearla.

No sustituye a la clave SSH ni elimina su frase de paso. Simplemente evita tener que introducirla continuamente mientras trabajamos.

En Git Bash podemos iniciar el agente con:

eval "$(ssh-agent -s)"

Obtendremos un mensaje similar a:

Agent pid 1234

Ahora añadimos nuestra clave:

ssh-add ~/.ssh/id_ed25519

En este momento se solicitará la frase de paso:

Enter passphrase for /c/Users/.../.ssh/id_ed25519:

Una vez introducida correctamente, la clave queda disponible en el agente.

Podemos comprobarlo con:

ssh-add -l

A partir de ahora, durante esa sesión de trabajo:

ssh-add
   ↓
introducimos la frase de paso
   ↓
ssh-agent mantiene disponible la clave
   ↓
   ├── git pull
   ├── git push
   └── git fetch
        ↓
no necesitamos introducirla repetidamente

ssh-agent no es necesario para utilizar SSH. Es simplemente una comodidad para evitar introducir repetidamente la frase de paso.

Al apagar o reiniciar el ordenador, la clave ya no permanecerá desbloqueada en ese agente. En una nueva sesión de trabajo tendremos que volver a ejecutar:

eval "$(ssh-agent -s)"
ssh-add ~/.ssh/id_ed25519

y volveremos a introducir nuestra frase de paso una sola vez al comenzar la sesión de trabajo. Mientras el agente permanezca activo, no será necesario introducirla de nuevo.

Si queremos eliminar manualmente las claves cargadas en el agente antes de terminar:

ssh-add -D

Este comando no elimina nuestra clave privada de .ssh ni la clave pública registrada en GitHub. Solo elimina las identidades que estaban cargadas en el agente.

4.6. Cambiar el remoto de HTTPS a SSH

Si ya tienes un repositorio local conectado con GitHub mediante HTTPS, puedes cambiar la dirección del remoto para que utilice SSH.

Comprueba la configuración actual:

git remote -v

Si el repositorio utiliza HTTPS aparecerá algo similar a:

origin  https://github.com/TU_USUARIO/TU_REPOSITORIO.git (fetch)
origin  https://github.com/TU_USUARIO/TU_REPOSITORIO.git (push)

Cambia la dirección de origin para utilizar SSH:

git remote set-url origin git@github.com:TU_USUARIO/TU_REPOSITORIO.git

Comprueba nuevamente la configuración:

git remote -v

Ahora debería aparecer:

origin  git@github.com:TU_USUARIO/TU_REPOSITORIO.git (fetch)
origin  git@github.com:TU_USUARIO/TU_REPOSITORIO.git (push)

A partir de este momento, las operaciones con ese remoto, como git pull, git fetch o git push, utilizarán SSH.

Realiza algún cambio sencillo en el proyecto, crea un commit y comprueba finalmente que puedes enviarlo a GitHub:

git push

Si no existiera todavía un remoto llamado origin, set-url no podría modificarlo. En ese caso podríamos añadirlo mediante:

git remote add origin git@github.com:TU_USUARIO/TU_REPOSITORIO.git

5. Automatizar el inicio de ssh-agent (OPCIONAL)

Este apartado es opcional y NO forma parte de los requisitos de finalización de la práctica.

Cada vez que comenzamos una nueva sesión estamos ejecutando los mismos dos comandos:

eval "$(ssh-agent -s)"
ssh-add ~/.ssh/id_ed25519

Podemos automatizarlos mediante un pequeño script y crear un alias para ejecutarlo fácilmente desde cualquier directorio.

Abre la terminal de Git Bash y crea el archivo:

nano ~/iniciar-ssh.sh

Escribe:

#!/bin/bash

eval "$(ssh-agent -s)"
ssh-add ~/.ssh/id_ed25519

Guarda el archivo y dale permiso de ejecución:

chmod +x ~/iniciar-ssh.sh

Podríamos ejecutarlo mediante:

~/iniciar-ssh.sh

pero podemos facilitar todavía más su uso creando un alias.

Un alias permite asociar un nombre corto a otro comando. Añade el siguiente alias al archivo ~/.bashrc:

echo "alias iniciar-ssh='~/iniciar-ssh.sh'" >> ~/.bashrc

Para aplicar el cambio en la terminal actual:

source ~/.bashrc

A partir de ahora, desde cualquier directorio podremos ejecutar simplemente:

iniciar-ssh

El proceso será:

iniciar-ssh
     ↓
ejecuta ~/iniciar-ssh.sh
     ↓
inicia ssh-agent
     ↓
añade ~/.ssh/id_ed25519
     ↓
solicita la frase de paso

El alias permanecerá disponible en las siguientes sesiones de Git Bash porque está definido en ~/.bashrc.

El script no almacena la frase de paso. ssh-add seguirá solicitándola al comenzar la sesión de trabajo.

Este ejemplo muestra dos mecanismos habituales para automatizar nuestro trabajo en la terminal:

• Un script permite agrupar varios comandos que queremos ejecutar juntos.
• Un alias permite asignar un nombre sencillo a un comando que utilizamos frecuentemente.

6. Comprobaciones de finalización

• La clave privada permanece en el equipo y está protegida mediante una frase de paso.
• GitHub tiene registrada únicamente la clave pública.
• ssh -T git@github.com confirma la autenticación.
• Si la red bloquea el puerto 22, SSH funciona mediante el puerto 443.
• Comprendes que ssh-agent es opcional y sirve para evitar introducir repetidamente la frase de paso durante una sesión.
• git remote -v muestra una dirección SSH para origin.
• Una prueba de git push funciona correctamente mediante SSH.

7. Ejercicios y entregables

1. Comprueba si ya dispones de una clave SSH y, si no existe, genera una clave ed25519 protegida mediante una frase de paso.
2. Registra la clave pública en GitHub.
3. Verifica la conexión SSH con GitHub.
4. Si la red bloquea el puerto 22, configura la conexión mediante el puerto 443.
5. Inicia ssh-agent, añade tu clave y comprueba que está cargada.
6. Cambia un repositorio de prueba de HTTPS a SSH y realiza un push.

Ampliación opcional: crea el script iniciar-ssh.sh explicado en el apartado 5 y comprueba que puedes utilizarlo al comenzar una nueva sesión.

Entregables

• Entrega la URL del repositorio y capturas de ssh -T y git remote -v, ocultando correos, nombres de usuario si el centro lo requiere y cualquier material privado.

8. Solución orientativa

Tu resultado es correcto cuando la clave privada permanece protegida mediante una frase de paso, la clave pública aparece registrada en GitHub y la conexión SSH se ha verificado correctamente.

Si utilizas ssh-agent, puedes consultar las claves que mantiene disponibles mediante:

ssh-add -l

y eliminarlas del agente cuando sea necesario mediante:

ssh-add -D

El remoto debe mostrar una URL SSH con esta forma:

origin  git@github.com:TU_USUARIO/TU_REPOSITORIO.git (fetch)
origin  git@github.com:TU_USUARIO/TU_REPOSITORIO.git (push)

El comando:

ssh -T git@github.com

debe informar de que la autenticación se ha realizado correctamente y de que GitHub no proporciona acceso a una shell.

Si la red bloquea el puerto 22, ~/.ssh/config permitirá utilizar ssh.github.com mediante el puerto 443 manteniendo en el repositorio la dirección SSH habitual:

git@github.com:TU_USUARIO/TU_REPOSITORIO.git

Fuentes y referencias

• Conectar a GitHub mediante SSH.
• Generar una nueva clave SSH.
• Añadir una clave SSH a la cuenta.