Tener Git y VS Code vinculados, y manejar dos cuentas sin arriesgar ninguna

Confirmar que VS Code detecta Git

Abre la terminal integrada (Ctrl+ñ) y corre:

# Muestra la versión instalada; si da error, instala Git desde git-scm.com primero
$ git --version

Si te devuelve algo como git version 2.4x.x, VS Code ya puede usarlo — vas a ver el ícono de "Control de código fuente" (una rama) en la barra lateral izquierda activarse en cualquier carpeta con un repo.

Iniciar sesión en GitHub desde VS Code

Abajo a la izquierda de la ventana hay un ícono de persona ("Accounts"). Haz clic → "Sign in with GitHub". Se abre el navegador, inicias sesión con la cuenta que quieras usar en ese momento, y vuelves a VS Code ya autenticado. También aparece este mismo cartel si usas el botón "Publish to GitHub" desde el panel de Control de código fuente.

Configurar tu identidad de Git (quién firma los commits)

Esto es independiente del paso anterior. Se hace por terminal, una sola vez por cuenta:

# Nombre que va a aparecer como autor en tus commits
$ git config --global user.name "Tu Nombre"
# Correo asociado a esos commits (idealmente el mismo de tu cuenta de GitHub)
$ git config --global user.email "tu-correo@ejemplo.com"

El flag --global significa "esta es mi identidad por defecto en todos los repos de esta computadora". Más abajo (paso 03) vas a ver cómo pisar este valor solo en el repo de la clase.

Cerrar sesión o abrir una ventana de incógnito

Para no crear la cuenta nueva "adentro" de tu sesión personal, abre una ventana de incógnito del navegador antes de ir a github.com/signup.

Elegir el nombre de usuario

La convención pedida es apellidoPaterno_apellidoMaterno_nombres. Hay un problema técnico: GitHub no permite guiones bajos (_) en el nombre de usuario — solo letras, números y guiones medios (-), y no puede empezar ni terminar con guion.

Usar un correo real y distinto al de tu cuenta personal

GitHub no deja repetir el mismo correo en dos cuentas. Si no tienes un segundo correo, se puede crear uno nuevo gratis (Gmail/Outlook) solo para esta cuenta de clase.

Verificar el correo y completar el perfil

Confirma el mail de verificación y completa el nombre visible como se indicó en el paso 02.

Ubícate dentro de la carpeta del repo de la clase

# Entra a la carpeta de tu repo de la clase (ajusta la ruta a la tuya)
$ cd portafolio

Configura la identidad LOCAL de este repo con la cuenta de clase

# SIN --global: esto solo vale adentro de la carpeta "portafolio"
$ git config user.name "Prado Diaz Bernardo"
# El correo de la cuenta NUEVA de clase, no el personal
$ git config user.email "prado-diaz-bernardo@ejemplo.com"

Confirma que quedó bien, sin adivinar

# Muestra el valor EFECTIVO (el local, si existe, gana sobre el global)
$ git config user.name
Prado Diaz Bernardo
$ git config user.email
prado-diaz-bernardo@ejemplo.com

# Muestra DE DÓNDE sale cada valor: si dice ".git/config" es local (de este repo);
# si dice algo como "C:/Users/tu-usuario/.gitconfig" es tu global (personal)
$ git config --list --show-origin | grep user

Generar el token en la cuenta de clase (en el navegador)

Logueado en github.com con la cuenta de clase: Settings → Developer settings → Personal access tokens → Generate new token. Cópialo (solo se muestra una vez).

Si Windows ya guardó otra credencial para github.com, bórrala primero (en Windows, fuera de VS Code)

Panel de Control → Administrador de credenciales → Credenciales de Windows → busca una entrada tipo git:https://github.com → Quitar. Así el próximo push te vuelve a preguntar usuario y token, en vez de reusar la cuenta vieja en automático.

Hacer push y cargar la credencial de clase cuando la pida

# Sube tus commits a GitHub; como es la primera vez, VS Code/Git te va a pedir usuario y contraseña
$ git push -u origin main
# Usuario: el username de la cuenta de CLASE
# Contraseña: pega el TOKEN generado en el paso 01 (no tu contraseña de GitHub)

Generar una clave SSH nueva, solo para la cuenta de clase

# -f le da un nombre de archivo distinto al de tu clave personal, si ya tenías una
$ ssh-keygen -t ed25519 -C "prado-diaz-bernardo@ejemplo.com" -f ~/.ssh/id_ed25519_clase

Presiona Enter en la frase de contraseña si quieres dejarla vacía (más simple para clase).

Cargar la clave en el agente SSH

# Arranca el "agente" que va a tener la clave lista en memoria durante esta sesión de la Terminal
$ eval "$(ssh-agent -s)"
# Carga tu clave privada de clase en ese agente
$ ssh-add ~/.ssh/id_ed25519_clase

Copiar la clave pública (en VS Code) y pegarla en GitHub (paso final en el navegador)

# Muestra la clave pública en la Terminal integrada de VS Code para poder seleccionarla y copiarla
$ cat ~/.ssh/id_ed25519_clase.pub

En github.com (logueado como cuenta de clase): Settings → SSH and GPG keys → New SSH key → pega el contenido.

Crear un alias de host para que Git sepa qué clave usar

Abre el archivo directamente en VS Code desde la Terminal integrada (si no existe, este comando lo crea):

# El comando "code" abre ese archivo como una pestaña más de VS Code, creándolo si no existe
$ code ~/.ssh/config

Con el archivo ya abierto como pestaña de VS Code, escribe (o completa) esto:

# Tu cuenta personal (si ya usabas SSH con ella)
# Host: el alias que vas a escribir en la URL remota en vez de "github.com"
Host github.com-personal
  # HostName: el servidor real al que se conecta SSH detrás del alias
  HostName github.com
  # User: SIEMPRE "git" — es el usuario técnico del protocolo SSH de GitHub, no tu username
  User git
  # IdentityFile: qué clave PRIVADA usar cuando se use este alias
  IdentityFile ~/.ssh/id_ed25519_personal

# Tu cuenta de clase, con un alias distinto
Host github.com-clase
  # mismo servidor real que arriba
  HostName github.com
  # sigue siendo "git", no tu username de clase
  User git
  # aquí apunta a la clave privada de la cuenta de CLASE, no a la personal
  IdentityFile ~/.ssh/id_ed25519_clase

Guarda con Ctrl+S desde VS Code, como cualquier otro archivo.

Apuntar el repo de la clase al alias "github.com-clase"

# Reemplaza la URL remota para que use el alias con la clave de clase
$ git remote set-url origin git@github.com-clase:prado-diaz-bernardo/portafolio.git
# Verifica que quedó apuntando al alias correcto
$ git remote -v

De ahora en más, cualquier git push/git pull en esta carpeta usa automáticamente la clave de la cuenta de clase — sin preguntarte usuario ni contraseña, y sin poder confundirse con la personal.

¿Qué identidad va a firmar mi próximo commit?

# Sin valor a la derecha del "=": git config MUESTRA el valor actual en vez de cambiarlo
$ git config user.name
# Lo mismo para el correo
$ git config user.email

¿Con qué cuenta remota se va a autenticar el push?

# Si usas SSH con alias: fíjate cuál alias aparece (github.com-clase o -personal)
$ git remote -v

¿En qué rama estoy?

# Imprime SOLO el nombre de la rama actual, nada más
$ git branch --show-current
# o, más completo: nombre de rama + qué archivos tienes modificados/sin guardar en el commit
$ git status

En VS Code, la rama actual también se ve siempre abajo a la izquierda de la ventana, junto al ícono de sincronización — hacer clic ahí abre el selector de ramas.

¿Quién firmó el último commit? (por si ya commiteaste)

# -1: solo el último commit. --format="%an <%ae>": muestra el nombre y el correo del autor, nada más
$ git log -1 --format="%an <%ae>"

Crear un atajo git whoami (se configura una sola vez, es global y no rompe nada)

# --global alias.whoami "...": define un comando nuevo llamado "whoami", disponible en cualquier repo
# El "!" al inicio le dice a Git "lo que sigue son varios comandos de shell", no un solo comando de Git
# Encadenados con && : primero muestra el nombre, después el correo, después la rama actual
$ git config --global alias.whoami "!git config user.name && git config user.email && echo rama: $(git branch --show-current)"

Esto es un alias global de Git: no toca tu identidad ni la de nadie, solo agrega un atajo de lectura que vas a poder usar en cualquier repo, de cualquiera de tus dos cuentas.

Párate en tu repo personal y confirma

# cd: te "mueves" a esa carpeta dentro de la Terminal integrada de VS Code (ajusta la ruta a la tuya)
$ cd ~/proyectos/mi-repo-personal
# Corre el alias que creaste en el paso 01
$ git whoami
Bernardo Prado
bernardopradodiaz@gmail.com
rama: main

Esta es la identidad global (tu cuenta personal), porque este repo nunca tuvo una configuración local que la pisara.

Ve al repo de la clase y confirma que cambió

# Te mueves a la carpeta del repo de la materia
$ cd ~/proyectos/portafolio
# Mismo alias, otra carpeta
$ git whoami
Prado Diaz Bernardo
prado-diaz-bernardo@ejemplo.com
rama: main

Cambió solo porque en el Paso 03 configuraste la identidad LOCAL de esta carpeta. No moviste ningún interruptor: cada carpeta "recuerda" quién eres ahí.

Vuelve al repo personal y confirma que NO se mezcló

# Vuelves a la carpeta personal
$ cd ~/proyectos/mi-repo-personal
# Chequeo final
$ git whoami
Bernardo Prado
bernardopradodiaz@gmail.com
rama: main

Sigue siendo tu identidad personal, intacta. Ese es el punto: cd a la carpeta correcta + git whoami antes de commitear es todo lo que hace falta para moverte entre las dos cuentas sin arriesgar ninguna.

Nunca usaste Git ni GitHub

Instala Git → Paso 01 completo, usando de una vez la cuenta de clase como identidad global (no tienes cuenta personal todavía que proteger).

Ya tienes cuenta personal configurada como global, y vas a clonar/crear el repo de clase

1. Crea la cuenta de clase (Paso 02).
2. NO toques tu git config --global — déjalo con tu identidad personal.
3. Entra a la carpeta del repo de clase y configura la identidad LOCAL (Paso 03).
4. Elige Opción A o B de autenticación (Paso 04) usando la cuenta de clase.
5. Antes del primer git push, corre los 4 chequeos del Paso 05.

Ya tienes varios repos personales con SSH, y no quieres tocar esa configuración

Usa Opción B (SSH con alias) del Paso 04 tal cual está escrita: tu clave y alias personales quedan intactos, y agregas un alias nuevo (github.com-clase) solo para el repo de la materia.

Trabajas la clase desde dos computadoras distintas

Repite el Paso 03 (identidad local) en cada máquina — es información que vive dentro de la carpeta .git de ESE repo en ESA compu, no se sincroniza sola. Si usas Opción B de autenticación, genera una clave SSH de clase distinta en cada máquina y agrega ambas a la cuenta de clase en GitHub.

Caso fácil: el commit todavía NO se subió (no hiciste push)

Corrige la identidad local (Paso 03) y después arregla el autor del último commit sin crear uno nuevo:

# Reescribe el autor del ÚLTIMO commit con la identidad correcta ya configurada
$ git commit --amend --author="Prado Diaz Bernardo " --no-edit

Caso delicado: el commit YA se subió a GitHub (ya hiciste push)

Corregir esto reescribe el historial y requiere git push --force, lo que puede pisar trabajo de otra persona si el repo es compartido.

Si igual necesitas hacerlo: corrige el autor con --amend como en el paso anterior, y luego:

# Sube la versión corregida, reemplazando la que ya estaba en GitHub
$ git push --force