Repositorio remoto

Hasta aquí, todo tu trabajo vivía en tu máquina (repositorio local). Un repositorio remoto (remote) es una copia alojada en un servidor (GitHub, GitLab, Bitbucket…), accesible para todo el equipo.

El repositorio remoto cumple tres roles: copia de seguridad (tu código sobrevive a un fallo de disco), compartir (el equipo accede al mismo código) y punto de encuentro (base de la colaboración y del CI/CD).

Para conectar tu repositorio local a un repositorio remoto, se le añade una referencia llamada por convención origin.

# Añadir el repositorio remoto llamado "origin"
git remote add origin https://github.com/utilisateur/mon-projet.git

# Verificar los repositorios remotos configurados
git remote -v

origin no es más que un nombre por convención para «el repositorio remoto principal». Se podría llamar de otra forma, pero todo el mundo usa origin — conserva esta convención.

🔧 Mini-ejercicio — Escribe el comando que enlaza tu repositorio local al repositorio remoto https://github.com/moi/projet.git bajo el alias origin.

git remote add origin https://github.com/moi/projet.git

Empujar (push) es enviar tus commits locales hacia el repositorio remoto.

# Primer push: se enlaza la rama local a la rama remota con -u
git push -u origin main

# Las veces siguientes, un simple push basta
git push

La opción -u (o --set-upstream) solo sirve una vez por rama: enlaza tu rama local a su gemela remota. Después, git push y git pull saben qué hacer solos.

🔧 Mini-ejercicio — Escribe el comando del primer push de la rama main hacia origin, estableciendo el seguimiento.

git push -u origin main

Cuando un compañero empuja código, debes recuperar sus cambios para seguir al día.

# Recuperar Y fusionar los cambios remotos
git pull

# Recuperar SIN fusionar (para inspeccionar primero)
git fetch

Buena costumbre: haz git pull antes de empezar a trabajar y antes de empujar. Eso evita la mayoría de los conflictos, porque partes siempre de la versión más reciente.

🔧 Mini-ejercicio — ¿Qué comando recupera los commits remotos sin fusionarlos en tu rama, para inspeccionarlos primero?

git fetch

Clonar (clone) es crear una copia local completa de un repositorio remoto existente — típicamente para unirse a un proyecto.

# Clonar un repositorio (crea una carpeta + descarga todo el historial)
git clone https://github.com/utilisateur/mon-projet.git

# Clonar en una carpeta con un nombre preciso
git clone https://github.com/utilisateur/mon-projet.git mon-dossier

git clone hace todo de una vez:

1. Descarga el repositorio entero (archivos + historial).
2. Crea una carpeta local.
3. Configura automáticamente origin hacia la URL clonada.

Resumen: se clona cuando el proyecto ya existe en línea; se hace init + remote add + push cuando se parte de un proyecto local a publicar.

🔧 Mini-ejercicio — Escribe el comando que clona el repositorio https://github.com/moi/projet.git en una carpeta local llamada mon-dossier.

git clone https://github.com/moi/projet.git mon-dossier

Este es el ciclo diario completo del trabajo colaborativo con un repositorio remoto.

Este flujo pull → trabajar → commit → pull → push es la rutina de base. En empresa se añaden las Pull Requests y la revisión de código — es el objeto del módulo 02 (Git avanzado y GitHub).

Question 1: ¿Qué es un repositorio remoto?

a) Una rama local

b) Una copia del repositorio alojada en un servidor, accesible para el equipo

c) Un archivo .gitignore

d) Un commit particular

Question 2: ¿Qué designa habitualmente origin?

a) El primer commit del proyecto

b) El nombre por convención del repositorio remoto principal

c) La rama por defecto

d) Un tipo de conflicto

Question 3: ¿Qué comando envía tus commits locales hacia el remoto?

a) git pull

b) git push

c) git clone

d) git fetch

Question 4: ¿Cuál es la diferencia entre git fetch y git pull?

a) Ninguna, son sinónimos

b) fetch descarga sin fusionar; pull descarga y fusiona

c) pull borra el historial

d) fetch envía los commits

Question 5: ¿En qué caso se usa git clone?

a) Para publicar un proyecto local vacío

b) Para recuperar una copia completa de un repositorio que ya existe en remoto

c) Para crear una rama

d) Para resolver un conflicto

Consigna

Publica el repositorio local creado en la lección 04 en GitHub, luego simula una colaboración clonándolo en otro sitio.

Corrección — Secuencia de comandos esperada

# --- Lado proyecto local existente ---

# 1. Crear un repositorio VACÍO en github.com (vía la interfaz web)
#    → se obtiene una URL : https://github.com/vous/mon-premier-depot.git

# 2. Enlazar lo local con lo remoto
git remote add origin https://github.com/vous/mon-premier-depot.git
git remote -v

# 3. Empujar por primera vez
git push -u origin main

# --- Simular a un compañero que se une al proyecto ---

# 4. Clonar en otro sitio (otra carpeta)
cd ..
git clone https://github.com/vous/mon-premier-depot.git copie-collegue
cd copie-collegue

# 5. Modificar, commitear, empujar
echo "Contribución del compañero" >> README.md
git add README.md
git commit -m "Añade una contribución"
git push

# --- Vuelta al proyecto de origen ---

# 6. Recuperar la contribución
cd ../mon-premier-depot
git pull

Resultado esperado: tras el git pull final, el archivo README.md del proyecto de origen contiene la línea añadida por el «compañero». El ciclo push / clone / push / pull está cerrado.

Acabas de realizar una colaboración Git completa tú solo. Es exactamente lo que ocurre en equipo, salvo que las dos copias están en máquinas distintas.

Puntos a recordar

1. Repositorio remoto = copia en servidor (GitHub): copia de seguridad + intercambio + colaboración.
2. git remote add origin <url> enlaza lo local con lo remoto.
3. git push envía; git pull (= fetch + merge) recibe.
4. git clone recupera un repositorio existente y configura origin automáticamente.
5. Rutina diaria: pull → trabajar → commit → pull → push.

A continuación

Módulo 02 — Git avanzado y GitHub: Pull Requests, revisión de código, gestión de conflictos en equipo y workflows profesionales.