Uso de GitHub

Ahora se viene lo chido

Si a ustedes no les sale el mensaje de que se tiene que traer los cambios y al intentar hacer el pull les dice que todo está actualizado es porque GitHub cambió su rama por defecto a “main” y nosotros estamos trabajando con la rama master, por tanto GitHub lo está tomando como un pull request (Porque sond iferentes ramas)

Para seguir esta clase deben borrar el repositorio en GitHub (Si ya lo tenían creado) y configurar su rama por defecto como master en:

https://github.com/settings/repositories

En el apartado “Repository default branch” borran main y escriben “master” y le dan al botón de actualizar, después vuelven a crear su repositorio “hyperblog” en GitHub y continuan la clase normal

Muchahos, a tener en cuenta:
GitHub en Octubre 2020 decide llamar la rama ‘master’ a rama ‘main’, lo que significa que en cuanto ha la clase han ocurrido unos cambios.
Al ejecutar el comando:

git push origin master

Estamos diciéndole a git que envíe a origin(remoto) la rama ‘master’ de nuestro repositorio local. Por lo tanto, en GitHub se interpreta como adicionar una rama independiente llamada ‘master’ con su contenido a bordo, pero no se carga en la rama default de GitHub, debido a que su rama default ahora se llama ‘main’.
Para alinear el contenido de Freedy y la actualización de GitHub, en la practica el comando para realizar el push según el nuevo estándar seria:

git push origin master:main

En donde le estamos diciéndole a git que envíe a origin(remoto) la rama ‘master’ de nuestro repositorio local hasta la rama ‘main’ del servidor remoto. De igual manera, dentro de esta nueva lógica:

git pull origin main --allow-unrelated-histories

En donde estamos trayendo desde el servidor remoto la rama ‘main’ fusionando las historias.
De tal manera que ya podemos continuar con el contenido de Freddy sin llegar a confundirnos.

Leí que GitHub se actualizó porque cambió su rama por defecto a “main” y nosotros estamos trabajando con la rama “master”, como Freddy. Por eso siempre me aparecía un error pero pude solucionarlo aplicando lo siguiente:

_Resumen _

A seguir aprendiendo! 😃

DOS ACTUALIZACIONES IMPORTANTES A NOV 2021 CON ESTA CLASE DE GITHUB

1. Al momento de conectar tu repositorio local con el repositorio remoto en Github, la consola te pide tu contraseña, por temas de seguridad el equipo de Github decidió que en ese espacio no vas a poner tu Contraseña sino algo que llaman Personal Access Token. Literalmente lo copias de GitHub y lo pegas en la consola cuando te pida tu contraseña de GitHub.

• Para poder proseguir con el curso les recomiendo seguir los pasos de este blog de GitHub para crear su propio PAT -> https://docs.github.com/en/authentication/keeping-your-account-and-data-secure/creating-a-personal-access-token

1. Como espero hayan leído en la clase 18, por temas de Racismo, Github dejó de utilizar la palabra “master”(asociada al concepto de Master-Slave que se usa mucho en todos estos temas de desarollo) y paso a usar la palabra “main”. Que quiere decir esto:

• Cuando intentas hacer pull origin master… le estás diciendo a GitHub, hey tráigase el branch master, y pues la consola al ver que no existe ningún branch llamado “master” en GitHub te dice que todo okey, pero pues no te trajiste el archivo Readme. Entonces claramente no todo okey.
• Cuando intentas hacer el push origin master… le estás diciendo a GitHub hey créese un branch llamado master y ahí métale esto que le estoy mandando.
• En ambos casos, todo mal porque estás interactuando con un Branch que para GitHub no es el principal, el Branch Principal de GitHub se llama ahora “main”.
• Qué puedo hacer? -> Cambia el nombre de tu branch “master” local a “main”
• Cómo puedo cambiar el nombre de un branch -> Ejecuta el siguiente comando en la consola = git branch -m oldName newName
• Cada vez que Freddy diga/escriba “master” para ti es “main”.
• Repito -> Cuando en el curso Freddy diga o escriba “master” tu lo vas a reemplazar por “main”.

Espero les sirva!

Si ustedes son igual de despistados que yo y pusieron la clave SSH en lugar de la HTTPS en el origin ejecuten éste comando para que se borre lo que hicieron:

git remote remove origin

Hola quisiera compartir el siguiente link https://youtu.be/hlYkxZrdeBI , de acuerdo a la actualización realizada por Git a partir de agosto del 2021 debemos crear un Token para poder realizar Push.

Esto cada vez se pone mejor

*******************
****Iniciar Git****
*******************

git int

*******************
****Iniciar Git****
*******************

**********************************
*******Configuración de Git*******
**********************************

git config
git config --list
git config --list --show origin
git config --list --show-origin
git config --global
git config --global user.name "SC"
git config --global user.email "[email protected]"

**********************************
*******Configuración de Git*******
**********************************

********************************************
******Agragar a la zona de preparación******
********************************************

git add Archivo.txt

git add .

********************************************
******Agragar a la zona de preparación******
********************************************

****************************
*********Ver estado*********
****************************

git status

****************************
*********Ver estado*********
****************************

***************************************************************************
*****************Quitar de la zona de preparación**************************
***************************************************************************

git rm --cached archivo.txt (Quitar de la zona de preparación).

***************************************************************************
*****************Quitar de la zona de preparación**************************
***************************************************************************

************************************************************
**********************Realizar commint**********************
************************************************************

git commit -m "Este es el pimer commit de este archivo"
git commit -am "Este es el pimer commit de este archivo"

************************************************************
**********************Realizar commint**********************
************************************************************

*****************************************************
*******Ver el historial de cambios del archivo*******
*****************************************************

git log
git log Archivo.txt

*****************************************************
*******Ver el historial de cambios del archivo*******
*****************************************************

***************************************************************
************Muestra todos los cambios sobre un archivo*********
***************************************************************

git show Archivo.txt

***************************************************************
************Muestra todos los cambios sobre un archivo*********
***************************************************************

**************************************
**********Comparar versiones**********
**************************************

git diff commint commint

**************************************
**********Comparar versiones**********
**************************************

*****************************************************************************
************************Volver a una versión anterior************************
*****************************************************************************

git reset commit --hard (borramos todos los cambios y lo que tengamos en staging) 

git reset commit --soft (soft conservamos cambios y lo que tengamos en staging) 

git checkout (commit) Archivo.txt

git checkout (rama) Archivo.txt
*****************************************************************************
************************Volver a una versión anterior************************
*****************************************************************************

****************************************************************************
**************************Ver Cambio en bytes*******************************
****************************************************************************

git log --stat(Cambio en bytes)

****************************************************************************
**************************Ver Cambio en bytes*******************************
****************************************************************************

***************************************************************************
****************************Crear una rama*********************************
***************************************************************************

git branch (branchName)

***************************************************************************
****************************Crear una rama*********************************
***************************************************************************


***************************************************************************
**************************Cambiar de rama**********************************
***************************************************************************

git checkout (branchName)

***************************************************************************
**************************Cambiar de rama**********************************
***************************************************************************

*******************************************************************
************************Merge entre branchs************************
*******************************************************************

git merge (branchName)

**Estar en la rama master o en la que se quiere dejar el <Head>**
*******************************************************************
************************Merge entre branchs************************
*******************************************************************

****************************************************
************Traer un repositorio externo************
****************************************************

git remote add origin (url)
git remote (muestra el origen)
git remote -v(es verval)

git pull origin master --allow-unrelated-histories (Fuerza la union de las diferentes historias)

git pull origin master (Descarga cambios)

git push (origin) (master) (Sube Cambios)
****************************************************
************Traer un repositorio externo************
****************************************************

Para los que tomen el curso en 2022 y ya no tengan soporte de contraseñas tienen que ir a settings en github, después developer settings y ahí le dan a personal access token y esa es su contraseña que deben poner para conectarse con el servidor remoto

Para quienes estamos haciendo el curso después de Julio de 2020 antes de hacer el push sería bueno cambiar el nombre de la rama master a main, es el nuevo estándar para la rama por defecto en GitHub. Se hace así:

$ git branch -m master main

Subir Proyectos a git:
-Paso1:
git remote add origin YOUR URL
-Paso2:
git pull origin master
-Paso3:
git pull origin master --allow-unrelated-histories
"ESC"+“SHIFF”+“ZZ”
-Paso4
git push origin master

Por si a alguien se le olvido (como a mi :v) esc shift z z para salir de vim.

La red social para Nerds. Es la primera vez que siento que no desperdicio mi tiempo usando una red social.

Deben actualizar esta clase ya que apartir de agosto 13 de 2021 Git hub a traves de git ya no acepta las operaciones basadas en nombre de usuario y contraseña de la cuenta de git hub.

POR FAVOR ES NECESARIO ACTUALIZAR LA CLASE
https://www.google.com/url?q=https://github.blog/2020-12-15-token-authentication-requirements-for-git-operations/&sa=D&source=hangouts&ust=1631988749472000&usg=AOvVaw3Ik3MRzpdpDzO4u6nP7SB4

Viendo este curso en el 2022, alguien más?

Tomé esta clase 4 veces XD hasta que me salió

No se cuantas cosas toque para subir mi proyecto al repo pero cambie la rama ‘master’ a ‘main’ con el comando ‘‘git branch -m main’’ y luego en https://github.com/settings/repositories cambie ‘master’ por ‘main’.
Utilice el comando ‘’’‘git pull origin main --allow-unrelated-histories’’’’ para traer la version del repositorio remoto. Luego use ‘‘git push origin main’’ y pude subirlo, pero anteriormente me aparecian miles de errores. Espero haber podido ayudar a alguien. Mas que nada es para la gente que lo esta viendo en 2021 xD

Les comento lo que me pasó al hacer git push origin main. (ya le cambié de nombre a la rama).
No tenía respuesta, nunca me salió ninguna opción para autenticarme, esto con Git Bash, luego me cambié de terminal, usé la de Visual Studio Code y funcionó, ya me visualizó opciones para autenticarme.

Si creaste un repositorio en Github en 2022, debes tomr encuenta dos cosas:

1. Debes debes hacer unas configuraciones en Git

# Primero: Guardar la URL del repositorio de GitHub
# con el nombre de origin
git remote add origin URL

# Segundo: Renombrar la rama master
git branch -M master main

# Tercero: Traer la versión del repositorio remoto e
# hice el merge para crear un commit con los archivos
# de ambas partes.
git pull origin main --allow-unrelated-histories

# Cuarto: hacer el git push para guardar
# los cambios de nuestro repositorio local en GitHub:
git push origin main

1. Debes crear un Token “Personal access tokens” en Github
   Te puedes ayudar de este VIDEO

A partir del 13 de agosto de 2021, GitHub exige un token para autenticarse cuando se usa protocolo HTTPS. Para crear un token:
Settings/Developer settings / Personal access tokens

Copiar el token y pegarlo cuando pida la contraseña después del push
Username for ‘https://github.com’: [email protected]
Password for ‘https://[email protected]@github.com’: (pegar aquí el token ejemplo ghp_xO4RK0xUJg3fAJMwc6ll1dOqvDWOkO16w3Dx)

En mi caso me aparecieron los siguientes errores:

! [rejected]        master -> master (fetch first)
error: failed to push some refs to 'https://github.com/vhngroup/CursoGitPlatzi.git'

Soluciòn:
Realizar primero un:

git fetch origin master

Luego al intentar nuevamente ejecutar el push, me apareciò este error:

! [rejected]        master -> master (non-fast-forward)
error: failed to push some refs to 'https://github.com/vhngroup/CursoGitPlatzi.git'

Soluciòn:

git push -f origin master

Fuente:

Nota:
Cambiar de rama a master, por que la clase anterior nos dejo en cabecera

En el minuto 8:00 cuando quieran hacer el merge forzado con el repositorio les salga el siguiente mensaje

fatal: Need to specify how to reconcile divergent branches.

Tienen que insertar este comando

git config pull.rebase false

y a continuación el comando

git pull origin master --allow-unrelated-histories

En el minuto 8:06 para salir de la ventana deben presionar Shif + z, dos veces como lo explicaba en anteriores clases

Resumen de la clase:
En GitHub vamos a tener un repositorio remoto, el cuál queremos enlazar con nuestro repositorio local para subir y traer cambios. En GitHub debemos crear nuestro repositorio y para enlazarlo al repositorio local debemos copiar la dirección _URL _dada en la pestaña **VERDE **clone or download, luego, pegar esta URL en el comando que sigue:

$git remote add origin _URL_ (Enlaza los dos repositorios)
$git remote  (Nos da el nombre del repositorio remoto)
$git remote  (Nos da el nombre con las opciones de fetch y push, es decir que está habilitado)

Antes de subir a nuestro repositorio remoto, es necesario traer su historia al local, se utiliza el comando:

$git pull origin master (Trae las historias al repositorio local de origin, particularmente la rama master)
//Si hay historias no relacionadas no será exitoso, se soluciona con:
$git pull origin master --allow-unrelated-histories (Resuelve el conflicto de historias no relacionadas entre ambos repositorios)

Luego de que nosotros hagamos cambios en el local debemos subirlos al repositorio remoto para que nuestro equipo tenga acceso a estas historias, se utiliza el comando:

$git push origin master (Sube todo al repositorio remoto)

Espero que les ayude.

en la parte de git pull origin master --allow-unrelated-histories para aceptar y salir de ahi se presiona esc+chif+zz

ya estoy haciendo push actualizando la informaciónde mis apuntes

Si quieren hacer primero fetch y luego el merge en lugar del pull directamente:

#git fetch origin master

esto descarga los archivos a algo llamado FETCH_HEAD a como lo indica la terminal

en este punto parece que no ha pasado nada ya que los cambios se encuentran en FETCH_HEAD, y tus archivos no han cambiado. Para que tus archivos cambien debes hacer el merge

#git merge FETCH_HEAD

De momento vamos bien, todo muy bien explicado. Estoy comenzando a crear mi propio repositorio en Git en donde pueda crear una pagina web estática y pueda alojar todos los comandos y lo que hace cada uno de ellos.

Para los que tienen problema al hacer el push, les comparto los pasos que realicé:

A) RENOMBRAR MASTER -> MAIN

git branch -m master main

B) FUSIONAR LAS RAMAS

git merge --allow-unrelated-histories origin/main

C) BAJAN LOS CAMBIOS PARA EVITAR CONFLICTOS

git pull origin main

D) SUBEN LOS CAMBIOS

git push origin main

A mi así me funcionó, Saludos.

Buenas, para quienes están viendo el curso en 2022, hace un tiempo que github ya no deja hacer el push con la contraseña del propio github, para esto tenemos que Crear un token y este token es la contraseña que vamos a colocar cuando les pida clave acá les explico cómo hacerlo para que puedan continuar la clase tranquilamente

Primero: Vamos a la parte de opciones y vamos a ir a settings

Segundo: Bajaremos hasta conseguir la opción que diga developer settings y hacemos click

Tercero: Nos vamos a ir a la opción que dice Personal acces token

Una vez allí vamos a dar click en generar un nuevo token

Nos aparecerá esto. Acá podremos generar nuestro token, en la nota, pueden colocar el nombre que le quieran poner o algo para lo que hayan creado ese token.
Tienen también la expiración, que es cuando se va a vencer el token (una vez el token expire no lo podrán usar denuevo)
Y debajo tienen unas opciones que son como los permisos que le quieren dar a su token, si solamente lo usarán para repositorios denle a la opción de “repo” y les selecciona todas las de esa ala

Luego bajan y le dan en generar token

Y por último, ya les crea su token, deben copiarlo en algún lugar, un bloc de notas o algo, porque va a desaparecer una vez cierren esa página y no podrán verlo nuevamente, tal cual como les dice el mensaje

Este curso esta mas desactualizado, que aburrido, si nunca has tocado git, talvez tengas muchos problemas, sigue estos pasos para que no tengas problemas:

1.- Fuerzas mover todo el directorio local a la rama main para que no haya conflicto con:

git branch -M main

2.- Traes el repositorio remoto con :

git remote add origin URL

3.- haces un pull con :

git pull origin main --allow-unrelated-histories

4.- Si tienes algún problema acá de conflicto usas la siguiente configuración:

git config pull.rebase false
Para unirlos a la fuerza
git config --global init.defaultBranch main
Para usar como configuración main en lugar de master
en todos los directorios que uses git de la pc
5.- Haces tu git push como quieras

TOKEN COMO RESOLVERLO
(Vamos a nuestro perfil en GitHub)
1-Vamos arriba a la derecha hacia nuestro perfil, y elegimos la opción SeSETTINGS
2-En la columna de la izquierda de la pagina elegimos la opción DEVELOPER SETTINGS
3-En la columna de la izquierda elegimos la opción PERSONAL ACCESS TOKENS
4-Ahora hacemos clic en el botón GENERATE NEW TOKEN
5-Una vez generado nos va a decir que le pongamos una descripción (en mi caso hice referencia al nombre del repositorio), luego en ++**SELECT SCOPES **++tildamos la opción REPO, luego bajamos y apretamos el botón GENERATE TOKEN
6-Una vez tenemos el TOKEN lo copiamos y ahora cuando nos pida que nos identifiquemos, ponemos el usuario y ++**AL MOMENTO DE LA CONTRASEÑA PEGAMOS EL TOKEN **++y problema solucionado.

Comandos a ser utilizados :
git remote add origin URL -Comando para guardar la url del repositorio de github
git remote -v -Comando para verificar que la URL se haya guardado corretamente, nos deberia traer la url donde hariamos el fecht y el push
git pull origin master --alow-unrelated-histories -Comando que trae la versión del repositorio remoto y hacer merge para crear un commit con los archivos de ambas partes.
git push origin master - Comando para enviar los cambios del repositorio local de git al repositorio remoto de github.com

Para los que les aparece

fatal: couldn't find remote ref master

Al escribir el siguiente comando:

git pull origin master --allow-unrelated-histories

Ingresen al link :
https://github.com/settings/repositories
Y cambien: main
por: master
Y actualizar
😉 !!

Para los que les salta el “error”

remote: Support for password authentication was removed on August 13, 2021. Please use a personal access token instead. remote: Please see https://github.blog/2020-12-15-token-authentication-requirements-for-git-operations/ for more information. fatal: unable to access “…” : The requested URL returned error: 403

acá esta la solucion

https://stackoverflow.com/questions/68775869/support-for-password-authentication-was-removed-please-use-a-personal-access-to

Me siento más seguro en gitbash, me asuste en github, suponiendo que es más sencillo.
Me da miedo todo esto, no se si es por lo que tengo tanto sueño…

Si les aparece este error:

es porque github ya no permite poner tu propia contraseña en la consola. En lugar de hacer eso, lo que procede es poner un personal access token (PAT), que se genera desde la página de Github y es un código que, al menos para este caso, reemplaza a la contraseña de la cuenta de Github. Para generar uno solo se deben seguir los pasos que salen en este link:

https://docs.github.com/en/authentication/keeping-your-account-and-data-secure/creating-a-personal-access-token

Y al final, cuando el sitio te dé el token, ponerlo en el lugar en que te piden tu contraseña.

OJO: esto me pasó en la consola de WSL. No sé si en el Git BASH de Windows sea igual.

Chicos alguinos vamos a tener el mismo problema que me a pasado el cual no sale la forma de logarnos en Gut bash

lo cual la única solución que logre encontrar es desde la terminal Visual studios code realizar los mismos pasos que nos indica Freddy en este video foto del ejemplo

espero que sea de ayuda ya que no logre encontrar otra solución

Saludos mis panas. Desde agosto GitHub decidió eliminar el uso de contraseñas para vincular Git con GitHub (tu repositorio local con el remoto). Esto lo hizo con motivos de seguridad.
.
Así que en vez de emplear tu contraseña personal de GitHub para acceder y manipular opciones remotas, tendrás que usar un Personal Access Token (PAT). El mismo es como una contraseña super larga que puedes generar en tu perfil (te muestro más adelante) y que tiene fecha de expiración.
.
Adicionalmente puedes meterla en un gestor de credenciales de GitHub que se llama GitHub CLI, simplemente para que no tengas que buscar ese token a cada rato cuando tengas que hacer operaciones remotas.
.
Generar un PAT:
.
Aquí esta el link de documentación oficial si quieres ver la fuente original: https://docs.github.com/en/authentication/keeping-your-account-and-data-secure/creating-a-personal-access-token
.

1. Verifica tu dirección de email de GitHub si todavía no lo has hecho.
   .
2. En la esquina superior derecha de GitHub dale click a tu icono de perfil y baja hasta settings. Clickea ahí.
   
   
   .
3. En la barra izquierda, baja y clickea la parte que dice “Developer settings”
   
   
   .
4. En la parte derecha clickea Personal Access Tokens
   
   
   .
5. Dale a “Generate new Token”
   
   
   .
6. Dale un nombre que describa la función del token, como “Repo’s deployer” por ejemplo.
   
   
   .
7. Dale un tiempo de expiración al token con la pestaña desplegable
   
   
   .
8. Selecciona los permisos o scopes que le quieras dar al token. Aquí le das al que dice directamente “repo” (con mucha probabilidad es el primero) y al de “delete_repo” si quieres también poder eliminar desde ahí.
   
   
   .
9. Click a generar token
   
   
   .
   
   
   .
   ¿Cómo usarlo en la consola?

$ git clone https://github.com/username/repo.git
Username: your_username
Password: your_token

Espero te haya servido de ayuda!

SUGERENCIA DE SOLUCIÓN A POSIBLES FALLOS EN 2022

Hola,

A diciembre de 2022 surge un problema debido a lo visto en el “modulo” 18, que como dice se ha cambiado de master a main.

Al crear el nuevo repositorio desde GitHub automáticamente lo crea con el tag de la rama “main”, mientras que si nosotros hemos seguido a Freddy al pie de la letra, desde Git la rama principal se sigue llamando “master”, si no sabemos el nombre de nuestras ramas ponemos el comando “git branch” y deberíamos ver “cabecera y master”.

Con el comando “git checkout master” nos posicionamos en master y ahora vamos a renombrarla a “main”:
Situados en master ejecutamos el comando: “git branch -m nombre-antiguo nombre-nuevo”.

De esta manera ya hemos cambiado el nombre de master a main. Ahora tenemos que borrar el repositorio creado en GitHub, desde nuestro repositorio (en la web), le damos a settings y abajo del todo le damos a “delete repository”.
(ESTO ES EN CASO DE YA HABER AVANZADO CON LA CLASE 19)

Una vez hechos estos pasos tendremos que crear el nuevo repositorio remoto que en la clase se llama “origin”. Con el comando “git remote -v” veremos que repositorios remotos tenemos creados y sus nombres (en el directorio/repositorio que estamos situados). Una vez vistos lo que debemos hacer es ejecutar el comando “git remote rm origin” y así eliminamos ese repositorio remoto llamado origin.

Y con esto ejecutamos git branch para ver que las ramas que tenemos son cabecera y main y ya podremos repetir la clase de hoy para que funcione perfectamente.

Espero que os sirva. 😃

Para los que vemos esta clase en el 2022, debemos cambiar el nombre de la rama principal en git por main, asi:

git branch -m main

Verficamos que quedo bien con:

git branch

Y ya despues si podemos seguir los pasos que Freddy hace, debemos tener en cuenta que debemos cambiar la palabra master por main y listo.

Yo no lo hice al principio y tuve que borrar en el Github una rama que me habia creado llamada master, pero despues de borrarla y cambiarle el nombre en el **Git **todo fue igual a la clase 😃 Espero les sea de ayuda.

Para quienes hacen el curso en el 2022, aquí dejo los pasos que seguí para enviar los archivos al repositorio remoto después de varios fracasos. Tuve problemas por eñ cambio de master a main.
__
__

1. Agregar la dirección del repositorio

git remote add origin "url_de_repositorio"

En algún momento necesité cambiar la url, y para ello utilicé:

git remote set-url origin <nueva_url_repositorio>

1. Cambie el nombre de “master” a “main”.

git branch -M main

1. Hice el push de acuerdo con la práctica de Fredy, pero en lugar de master utilice “main”. Lo demás quedó igual.

git push origin main

1. Hice el pull, igual sustituí master por “main”.

git pull origin main --allow-unrelated-histories

Despues de este paso, me apareció el editor de texto VIM, me pedía que colocara un mensaje para el commit. Lo que hice fue eliminar el texto de color amarillo que aparece en las primeras lineas y coloqué el texto de mi mensaje.
Recuerda para editar en VIM, presiona ESC y despues la tecla " i ". Para salir, presiona ESC y después Shift + Z Z.

1. Finalmente volví a lanzar el push hacia el servidor remoto:

git push origin main

1. Fui a la pestaña del navegador donde tenia abierto mi repositorio y le di actualizar. Me emocioné cuando vi mis archivos ahí, más porque al principio tuve problemas por lo del master y main.

Gente, yo tambien me volvi LOCO con el problema que nos pasó a la mayoria en el minuto 5 del video.

Nosotros trabajamos con la rama master como nos indica Freddy, si, pero desde hace un tiempo GitHub cambio por defecto su rama a “main”

Simplemente, desde Git, debemos cambiar el nombre de nuestra rama “master” a “main”

Como lo hacemos? con git branch -m main

Saludos, ya puedo proseguir con el curso (?

Para solucionar los problemas de la clase:

Inicialmente ya no se utiliza contraseña para iniciar sesión si no un token. Acá explican como generarlo. 👇
https://docs.github.com/en/authentication/keeping-your-account-and-data-secure/creating-a-personal-access-token

También tener en cuenta que ahora se utiliza main en ves de master, para modificarlo se debe hacer un:
git branch -m main

y por ultimo el push:
git push origin main

Debido a que en GitHub el HEAD principal se llama Main y en el GitBash se llama Master esto me trajo algunos problemas de compatibilidad siguiendo este Curso.
Por ejemplo, me creo una rama nueva en GitHub llamada Master aparte de la Main. Entonces teniendo en cuanta los cambios que vienen ahora en Octubre busqué como cambiar en el GitBash el Master por Main y ahí se me soluciono todo. Comparto el enlace por si a le sirve a otros estudiantes.
https://help.dreamhost.com/hc/es/articles/4466702078740-Configurar-git-para-usar-main-como-rama-principal

Inicio en GitHub y la fusión con Git
En GitHub seleccionamos New Repository, agregamos un README más una descripción y asignamos un nombre y copiamos la ruta de nuestro repositorio.
En la consola de nuestro proyecto en la rama master primero debemos cambiar el nombre de master a main con el comando
$ git branch -M main
Luego ejecutamos
$ git remote add origin url_repositorio
Con esto le decimos a git que cree un origen remoto de nuestros archivos.
$ git remote -v
El comando anterior lista los objetos remotos con sus respectivas URLs, una para bajar o traer archivos (fetch) y otra para subir o enviar archivos (push).
Antes que todo es necesario realizar un pull al repositorio remoto para enviar todo al repositorio local
$ git pull origin main
Hay archivos que tienen commit en GitHub pero no tienen historia en Git, estos archivos no bajan es necesario utilizar el siguiente comando, esto ocurre para el caso del README
$ git pull origin main --allow-unrelated-histories
Ahora que todo lo del remoto esta en el repositorio local se puede realizar el proceso de pasar nuestra rama master ya denominada main a nuestro repositorio remoto con el comando
$ git push origin main

saludo 😃

Si les aparece el siguiente error: fatal: Need to specify how to reconcile divergent branches.

Usen el siguiente comando: git config pull.rebase false
luego: git pull origin main
y finalmente el comando: git pull origin main --allow-unrelated-histories

espero les ayude porque me salía el error y no podía avanzar como Freddy hasta que pude solucionarlo con esos comandos.

Pasos para subir tu repositorio a Github (2022)

1. Crea el repositorio manualmente en Github. No olvides incluir el READMEmd como buena práctica
2. Copia la URL
3. Abre la consola y escribe git remote add origin "link del repositorio e github"
4. git remote -v Revisa la lista de conexiones existentes
5. git branch -m master main Cambia el nombre de la rama master a main, debido a que ahora Github usa el nombre “main”
6. git pull origin main Traer lo que se encuentra en el servidor remoto
7. git pull origin main --allow-unrelated-histories en caso de que el paso anterior de haya dado error
8. git push origin main Sube el repositorio local a Github

COMPARTO EL SIGUIENTE RESUMEN DE LA ÚLTIMA PARTE DE ESTA CLASE:
[git remote add origin <url copied from github>] Subir un proyecto a GitHub
[git remote] vemos (en consola) que hay algo que se llama “origin”
[git remote -v] sea verbal (explícito): indica una dirección url para hacer un “fetch” y otra para hacer un “push”.
[git push origin master] estamos diciendo: “git”, envíele al “origen” la rama “master”. Da el siguiente error:

Esto ocurre porque tenemos que integrar los cambios remotos localmente antes de volver a hacer un push. Para ello podríamos hacer git fetch > git merge o, mejor aún, ejecutamos el comando [git pull origin master]. Dió un mensaje de error diciendo que las dos historias (remota y local) no se encuentran relacionadas. Para solucionarlo ejecutamos el comando [git pull origin master --allow-unrelated-histories]. De esta manera fusionamos lo que tengo en el repositorio remoto con el local. Ahora si me permite hacer el merge con la rama master de mi proyecto (en este caso “Hyperblog”). Hacemos nuevamente [git pull origin master] y todo bien.
Luego voy a GitHub y veo mi proyecto allí. Para comprobar cómo funciona hacer cambios desde GitHub cambio el título en mi archivo “blogpost2.html”, luego hago commit desde la interfaz gráfica de GitHub. Luego regreso a mi consola y ejecuto [git pull origin master] y ¡listo! Me hizo los cambios en mi máquina local.

Traer y subir reporsitorio a GitHub:

1. Comando para Guardar la URL del Repositorio
   git remote add origin ligagithub.

2. Comando para verificar que la URL este guardada correctamente:
   git remote -v (Fecth = traer cosas)(Push = Enviar Cosas)

3. Comando para traer la version del repositorio remoto:
   git fecht
   git merge
   git pull origin master
   git pull origin master --allow-unrelated-histories (Este ultimo es para por si se presentan conflictos)

4. Guardar cambios del repositorio local a GitHub:
   git push origin master

para evitar dolores de cabesa les comparto este comando para que puedan cambiar la rama “master” a “main” permanente mente y no tenga que sufrir y cambiar a cada rato la rama “master” a cada rato

git config --global init.defaultBranch main

denle corazon jajajjaj

Me ha parecido muy aburrida esta clase porque a 2023 el curso está bastante desactualizado, lo cual no he podido seguir esta clase para nada, porque nada de lo que el dice me aplica. por favor actualicen el curso y así no perdemos tanto tiempo

GitHub es el cliente de git más popular, tanto que, se podría decir que es la red social del código, ésto porque te permite tener tus repositorios en la nube, tener un perfil profesional (con los aportes, tus repositorios y demás información de tu vidad de programador) y todo con un núcleo de git por dentro.

.

Como git es un VMS distribuído, entonces el código funciona en diferentes servidores (máquinas), pero para que vinculemos un servidor remoto tenemos que configurar un origen que indique con qué repositorio remoto estaremos trabajando, básicamente es una sintaxis que nos indica que le vamos a poner un pseudónimo a la url de dónde vamos a trabajar.

.

El comando para agregar un orígen remoto es:

git remote add origin <url_repositorio>

Donde:

• git remote = El comando que indica que vamos a trabajar con un servidor remoto
• add = Agrega un alias para el servidor remoto
• origin = Es el alias del servidor remoto (ésto para no tener que poner la url completa cada que quieres hacer un cambio)
• <url_repositorio> = Es la url dónde está el repositorio en la nube, en este caso de github (https://github.com/<tu_usuario_de_github>/<nombre_de_tu_repositorio>)

Ya que agregaste tu servidor remoto origin puedes jalaro o empujar los cambios, osea sincronizar tu servidor remoto con el local, para eso tenemos 2 comandos

• git pull: Jala los cambios del servidor, pero cómo podemos tener configurados diferentes repositorios remotos, tenemos que definir de dónde lo vamos a bajar y qué rama vamos a bajar, para eso podemos utilizar el siguiente comando:

  git pull <remoto> <rama>
  

  En el caso de la rama master y el remoto origin:

  git pull origin master
  

  Ésto bajará todos los cambios a tu local, pero si de pura casualidad la historia es diferente (el repositorio remoto tiene commits diferentes, puede ser un Readme nuevo) tienes que forzar bajar los cambios con el flag --allow-unrelated-histories.

  git pull origin master --allow-unrelated-histories
  

• git push: Empuja los cambios desde el local al remoto.

  git push <remote> <rama>
  

  La sintaxis es la misma que para el pull:

  git push origin master
  

Para aquellos que como yo, están haciendo el curso en abril de 2022 y no encuentran la opción de “Clone or download” para copiar la URL, simplemente hagan clic en la opción “Code” y les aparecerá la URL.

Este curso es tan práctico que de inmediato ya se pueden aplicar los conceptos al día a día

Hola ¿Cómo están?
Les dejo la solución a otro problema que tuve.

Error al mandar el repositorio desde la línea de comandos
En caso de que tengas el F2A activado en tu GitHub de seguro vas a tener el siguiente error al querer hacer un push.

➜  proyecto1 git:(master) git push origin master
Username for 'https://github.com': Mi-usuario
Password for 'https://[email protected]': mi-contraseña
remote: Invalid username or password.
fatal: Autenticación falló para 'https://github.com/repositorio/'

Al momento de poner tu contraseña no te la acepta y no puedes realizar tu push.
Para solucionarlo realizamos lo siguiente:

1. Desde tu cuenta de GitHub nos dirigimos a las configuraciones la cuenta.
   
   
2. Luego nos vamos a “Developer Settings”.
   
   
3. Damos click en “Personal access tokens”.
   
   
4. Nos vamos a “Generate new token”.
   
   
5. En “Note” colocamos un comentario sobre el token que vamos a crear, en donde lo vamos a usar o que lo ustedes quieran. Marcamos todas las opciones y le damos en “Generate token”.
   
   
6. Nos saldrá el token que debemos copiar en un lugar seguro. Una cosa a aclarar es que solo van a poder una única vez el token, una vez salgan de la pestaña o la actualicen desaparecerá el código.
   
   
7. Una vez copiado el token, hay que volver a hacer el push y colocar el token en el password.

➜  proyecto1 git:(master) git push origin master
Username for 'https://github.com': Mi-usuario
Password for 'https://[email protected]': mi-token

Espero les sirva. 😄

Hola Comunidad, estuve subiendo mi repositorio a GitHub y todo bien hasta que me apareció un problema de autentificación con Token, creo q hace parte de las ultimas actualizaciones de Git, me parecen muy rigurosas pero esta bien.

Entonces si llegan a tener es inconveniente es fácil, generan el token (aquí les explica como) si están en Windows editan las credenciales copiando el token en el password luego después del “git push” digitan su usario y en el password vuelven a pegar el token

En el grupo 5 de Telegram Road to code junto con @andresbonett, me ayudo a resolver un problema que se presenta ahora con la nueva configuración de GitHub.
“A partir del uno de octubre, los usuarios de GitHub dejarán de ver “master” y en su lugar aparecerá el término “main” (principal / por defecto). De todos modos, este cambio tendrá lugar en los nuevos repositorios.”

Para solucionar gran parte de los problemas se debe generar elmpush de la siguiente manera

PUSH

<git push origin master:main>

PULL

<git pull origin main>

Dejo enlace de la información
Link

Github ha facilitado las cosas con respecto al cambio de master a main, les recomiendo que al iniciar su repositorio local , una vez se les muestre master escribir:

   git branch  -M main

Cambia el nombre de la rama de master a main. Para hacer pull

  git pull origin main

De igual forma, como tip cuando crean el servidor remoto, github les indica que deben hacer, con respecto de master y main

Tengan en cuenta que ahora no se usa MASTER en GIT HUB. Deberían usan MAIN en lugar de MASTER. Por si tienen problemas con el PULL.

$ git pull origin main
$ git pull origin main --allow-unrelated-histories

$ git push origin main
Si esto da error con main:
$ git checkout -b main
Y luego de nuevo:
$ git push origin main

README.md es un archivo en donde puedes explicar qué hace tu código o en qué consiste tu proyecto. Es una buena practica debido a que cuando alguien entre a tu repo de GitHub podrá obtener ese tipo de detalles que le simplificarán muchas cosas ^^
Si deseas hacer un REAME muy entendible puedes utilizar Markdown, que es un lenguaje de marcado y es muy sencillo de aprender, acá dejo el link de su sintaxis: https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet
Espero que les sirva :3

PASOS PARA USAR GIT
//las barras hacen referencia a los comentarios|
//el archivos ejemplo.txt es un ejemplo de archivo|
//esta barra | sirve para indicar el final de un paso

1. apt-get install git|
   2)git init //en la carpeta que se desee intalar git|
   3)git add ejemplo.txt //para añadir el archivo al staging|
   4)git commit ejemplo.txt // o si se quiere toda la carpeta “.”| -m “aca va el mensaje que se adjunta al archivo” //para subir el archivo o sus cambios|

OTROS COMANDOS IMPORTANTES

#git status //para ver el estado de los archivos |
#git show //para ver los archivos|
#git diff // para comparar versiones de dos archivos|
#rm --cached ejemplo.txt //para remover el archivo de git|
#rm --force ejemplo.txt //para remover el archivo del git y del disco duro|
#git log ejemplo.txt //para ver las diferentes actualizaciones de un archivo|
#git checkout |numero de version| ejemplo.txt //para ver la version vieja de un archivo|
#git checkout master ejemplo.txt //para volver a la version mas reciente|
#git reset --hard //para volver en el tiempo pero borrando todo incluso en staging|
#git reset --soft // para volver en el tiempo sin perder el staging|
#git reset HEAD ejemplo.txt //nos permite sacar un archivo del staging para no enviarlo al git|
#git checkout cabecera //para cambiarse de la rama master a la cabecera|
USAR GITHUB

#git clone url //para traer el repositorio desde el servidor remoto|
#git fetch //para traer los archivos del servidor al repositorio local |
#git merge //para actualizar y fucionar el directorio de trabajo|
#git pull //union de fetch y merge|
#git push //sirve para subir todos los archivos a tu repositorio remoto|
#git remote add origin url //esto sirve para agregar algo a github|
#git pull origin master //para bajar los archivos a tu pc|
#git push origin master //para subir las cosas a github|
#git pull origin master --allow-unrelated-histories //para hacer el merge fusionado lo de tu pc con lo de github|

Estimados,
Para todos los que han tenido el problema que al ejecutar el comando:

$ git push origin main

y no ha pasado nada, independiente de la cantidad de tiempo de espera, les comento que Github ha cambiado sus “medidas de seguridad” por lo que pide pasos extras, les recomiendo realizar lo siguiente:

• Ejecutar el diagnóstico de dónde está el problema con el comando:

git_trace=1 git push -v origin main

• Si la última línea hace referencia a “git-credential-manager-core get” entonces les sucedió lo mismo que a mi.
• Deben ingresar a Descargar manager-core, según su versión de sistema operativo e instalar.
• Al ejecutar nuevamente el push, les abrirá la ventana para solicitar la cuenta de GitHub como en la imagen.
  
  
• Luego les pedirá autorizar desde el navegador si elegieron la opción de browser.
  
  
• Finalmente el push se realiza de forma correcta, si se validaron las credenciales.

Espero que les sirva si es que se encuentran en la misma situación.
Dejo la documentación de Credential-Manager Core

Hay un cambio muy importante que tengan presente me paso al intentar hacer el git pull, en el momento que instentava loguearme desde la consola me saltaba este error

Username for 'https://github.com': Password for 'https://braylin16@github.com': remote: Support for password authentication was removed on August 13, 2021. Please use a personal access token instead. remote: Please see https://github.blog/2020-12-15-token-authentication-requirements-for-git-operations/ for more information. fatal: Authentication failed for 'https://github.com/Braylin16/thecanario.git/'

y es porque github hizo unos cambios y la contraseña con la que te logueas en la página no es la misma con la que te conectas al repositorio, aqui encontre como solucionarlo. La otra alternativa es que vayas directo al video de como conectarse por ssh.

Porfa dame “Me gusta” a este aporte para que lo posicionen mas arriba y sea de ayuda para los que tienen este problema

antes de hacer: git push origin master, tener en cuenta que ahora en adelante master será main por los cambios en Github, por lo que debemos realizar primero:
git branch -M main, para que la info de master se pase a la nueva rama main, luego si:
git push origin main y seguir con el proceso…

Creo que ya es necesario una actualización del curso jejeje muchos quedaron perdidos con el tema de master - main, sin contar cuando GitHub te pide contraseña en la terminal pero que en realidad no tienes q poner tu contraseña sino un personal access token jajaja y ahi ya son mucho mas pasos!!

Debido al cambio de master a main en Github, realicé los siguientes para subir mi repositorio local a Github:

# Primero: Guardé la URL del repositorio de GitHub
# con el nombre de origin
git remote add origin URL

# Segundo: Estando en la rama master creé una nueva rama llamada main usando -M para copiar toda la historia de master
git branch -M main

# Tercero: Pasé a la rama main
git checkout main

# Cuarto: Eliminé la rama master
git branch -d master

# Quinto: Traje la versión del repositorio remoto e
# hice el merge para crear un commit con los archivos
# de ambas partes.
git pull origin main --allow-unrelated-histories

# Sexto: hice el git push para guardar
# los cambios de mi repositorio local en GitHub:
git push origin main

Bueno, tuve 2 errores para iniciar, logré solucionarlos al final, probablemente alguien tenga al menos 1 de estos errores que me topé, por lo que explicaré como solucionarlo, van un poco de la mano.
Error 1: Si eres usuario de GNU/linux (en mi caso trabajo con el sistema operativo ubuntu) te puedes topar con un problema de autenticación. Con git bach creo que no se tiene este problema, pero por sí lo llegan a tener los usuarios de windows, así lo solucioné:
1.1: En git nuestro HEAD recibe el nombre de master, por lo que al subir el repositorio local a github habrá un error por el hecho de que no coincide la rama master de git con la rama main de github. Para este primer paso, cambiamos el nombre de la rama master en git:

git branch -M main

1.2: Una vez solucionado ese error (ahora estoy creyendo que también se presenta en gitbach), viene el verdadero problema de autenticación (problema que en GNU/Linux puede suceder), para ello es mejor autenticarse por un token.
info: https://docs.github.com/es/authentication/keeping-your-account-and-data-secure/creating-a-personal-access-token.
(con solo habilitar el checkbox que dice repo es suficiente para poder subir y actualizar el repositorio)

1.3: una vez se tenga ese token, procedes a colocar el siguiente comando en terminal:

git config user.password  aqui_el_token

Con este comando pondrás el token como contraseña local en git, lo cual debe coincidir al autenticarte con el token en github.
(cada vez que el token se venza también será necesario que lo actualices en el repositorio local)

1.4: Finalizado eso, podrás aplicar el siguiente comando:

git push -u origin main

Este comando pide la autenticación, en el usuario pones el que tienes en github, y en password el token que generaste, que también pusiste en el comando del paso 1.3.

Error 2: de ahí salio el error 2 que puede que a todos se les presente, este puede ser el que a la mayoria se le presente.
Adjunto con copy y paste del error:
! [rejected] main -> main (non-fast-forward)
error: falló el push de algunas referencias a 'dirección del repositorio’
Este se puede solucionar con el siguiente comando:

git config pull.rebase true

rebase hace algo similar a merge, solo que si tienes más ramas, no se mantiene a salvo la historia de estas, solo la de la principal. Hay más comando para mantener a salvo estas ramas, por ejemplo el anterior solo que colocando false en vez de true, este realizará un merge.
info: https://platzi.com/tutoriales/1557-git-github/9123-cual-es-la-diferencia-entre-git-merge-y-git-rebase-y-cuando-usar-uno-u-otro/?utm_source=google&utm_medium=cpc&utm_campaign=17739691128&utm_adgroup=&utm_content=&gclsrc=aw.ds&&gclid=CjwKCAjw3K2XBhAzEiwAmmgrAhezQOk0LvgDgBBHDVXFPsud3XW1cRtyZO710TpqTDNGfPOMPKUCjBoCNpkQAvD_BwE
Por ultimo ya se pueden aplicar los 2 comandos finales:

git pull origin main

git push origin main

De esta manera ya se podrá subir todo al repositorio.

Para no tener inconvenientes, ya que desde el año 2020 se cambio el nombre de la rama de -master a -main, podemos realizar los siguientes comandos para modificar el nombre la rama:

De esta manera, podemos continuar con el curso, sin la necesidad de confundirnos o que llegue a suceder algún error en Git.

Si les dio un error al hacer el push en el ultimo paso, recuerden que deben cambiar la rama master local por rama main de esta forma

 git branch -M main

Despues si deja hacer el push con la cuenta de gitHub.

Hola Platzeros. Acá pueden poner en práctica y visualizar algunos de los comandos más importantes de Git y GitHub, en tiempo real:
http://onlywei.github.io/explain-git-with-d3/#commit
Have fun!

Antes de hacer push tengan en cuenta que master fue renombrada en github como main, entonces antes de hacer push…

git branch -M main

Y después continúen con el video 😃

Para los que tienen problemas desde el 2021 para adelante:
Todo lo que vean con master lo cambian por main (Ya lo explicó en un texto anteriomente)
Si por equivocación le dieron:

git remote add origin "el_enlace"

Lo pueden solucionar utilizando:

git remote remove origin 

Para eliminar o remover el enlace con el que se encuentran y de ahí comienzan de nuevo 😃

2021-Junio-27, me enfrente al problema de que no solicitaba las credenciales y no se podia hacer push al repositorio remoto.
Esto despues de investigar y varias pruebas di con lo siguiente y espero les sirva:
Si el comando

git push original main

Simplemente se queda colgado, ejecutenlo asi:

git_trace=1 git push -v origin main

Asi podran ver en que paso se queda, a mi particularmente me paso que se quedaba al obtener las credenciales por lo que tuve que eliminar del archivo config toda la seccion de "Credentials"
Una vez hecho esto, me empezo a aparecer la pantalla solicitando usuario y password para GitHub lo cual me alegro para poder seguir con la practica, pero poserior me llego un correo de parte de GitHub indicando que estaba usando una opcion “Deprecated”, asi que hay que usar su nuevo credential-manager-core.

Si están con Windows y Gitbash, y cuando ejecutan el comando git push origin master, se les queda colgada la instrucción, es debido a que está solicitando el ingreso de la autenticación pero no lo muestra, a mi me funcionó ejecutar el comando desde una terminal diferente a Gitbash en este caso usé Cmder y ahí ya pude continuar con la práctica. Espero sea de ayuda.

Hay algunos cambios en git, creo que el curso merece una actualizacion.

Por ejemplo al traer querer vincular el repositorio local con el remoto me pide darle un nombre, por defecto antes era origin.

Un consejo para evitarnos el problema que tuvo Freddy al vincular el repositorio deGitHub con el local, es que al momento de crear el repo en GitHub lo inicialicemos SIN EL README.md y nos hagamos el hábito de crearlo manualmente en cada uno de nuestros proyectos, así al momento de ejecutar $ git remote y hacer un $ git push no nos diga que la historia del remoto es diferente a la del local.

si tuviste conflictos por que en tu proyecto local la rama se llama master y en github se llama main y para evitarse crear de nuevo un repositorio basta con renombrar la rama master a main, esto usando:
git branch -m master main
Luego si se puede hacer:
git push origin main
y listo! 🤘🏽

Resumen de la clase

![](

Si a ustedes no les sale el mensaje de que se tiene que traer los cambios y al intentar hacer el pull les dice que todo está actualizado es porque GitHub cambió su rama por defecto a “main” y nosotros estamos trabajando con la rama master, por tanto GitHub lo está tomando como un pull request (Porque sond iferentes ramas)

Para seguir esta clase deben borrar el repositorio en GitHub (Si ya lo tenían creado) y configurar su rama por defecto como master en:

https://github.com/settings/repositories

En el apartado “Repository default branch” borran main y escriben “master” y le dan al botón de actualizar, después vuelven a crear su repositorio “hyperblog” en GitHub y continuan la clase normal

Para subir nuestro repositorio local al servidor de GitHub primero creamos uno en este. Hay que especificar título, descripción y README (opcional, pero es buena práctica hacerlo).
El README es un archivo que se va a visualizar en el momento que alguien entre a nuestro repositorio de GitHub. En este archivo escribiremos de que trata nuestro repositorio.
El repositorio puede ser público o privado.
Para traer el repositorio local al repositorio remoto vamos a la opcion de “Clone or download” en la página recién creada y elegimos la opción de HTTPS.
Ahora hace falta especificar el origen remoto de nuestros archivos con "git remote add origin master"
Antes de enviarlo primero tenemos que traernos los archivos del repositorio remoto con “git pull origin master” (con el parámetro --allow-unrelated-histories podemos fusionar las historias de los commit de ambas ramas)
Y ahora si, con “git push origin master” podremos finalmente enviar nuestros archivos y cambios al repositorio remoto.

este punto me llamo mucho la atención:
git pull origin [master] --allow-unrelated-histories

Comando que se usa para obligar a GIT a fusionar la historia de un repositorio local con un repositorio remoto. Este comando se ejecuta cuando se requiere conectar por primera vez ambos repos, debido a que al hacer ‘git pull origin master’ aparece el error: “fatal: refusing to merge unrelated histories”.

Compañeros, comparto lo que hice para que funcione todo bajo la rama main. Únicamente hay que cambiar de nombre a nuestro repositorio git de master a main con lo siguiente:

git branch -m master main

Solo basta con ejecutar esto antes de empezar a ver la clase.

Aprovechando todo lo aprendido para hacer un gits en mi cuenta de Github: https://github.com/ldmaroto/git-blog y https://github.com/ldmaroto/ssh-blog

Siempre tenia ese problema con los repositorios cuando les creadaba el readme.

Ahora ya sabre que hacer.

<git pull origin master --allow-unrelated-histories>

Aquí les va mi repo, con las notas. De paso aprendí un poco de MarkDown 😎

Tomar en cuenta que desde octubre del 2020 gitHub llama main al branch por defecto en lugar de master https://github.com/github/renaming

Otro tip importante a tener en cuenta es que si he subido un commit, y lo de modificado en local, puedo forzar a escribir el commit servidor usando

• git push --force origin master

Crear un nuevo repositorio en GitHub

1. En la esquina superior derecha, usa el menú desplegable (+) y selecciona Nuevo Repositorio.
   
   
   .
2. Utiliza el menú desplegable Propietario para seleccionar la cuenta que será propietaria del repositorio.
   
   
   .
3. Escribe un nombre para el repositorio, y una descripción opcional.
   .
4. Elige la visibilidad del proyecto.
   
   
   .
5. Si no estás utilizando una plantilla, hay una serie de elementos opcionales con los que puedes rellenar previamente tu repositorio. Si estás importando un repositorio existente a GitHub, no elijas ninguna de estas opciones, ya que podrías introducir un conflicto de fusión. Puedes añadir o crear nuevos archivos utilizando la interfaz de usuario, o elegir añadir nuevos archivos utilizando la línea de comandos más tarde.
   • Puedes crear un README, que es un documento que describe su proyecto.
   • Puedes crear un archivo .gitignore, que es un conjunto de reglas de ignorar.
   • Puedes elegir añadir una licencia de software para su proyecto.
   
   
   .
6. Por último, haz clic en Crear repositorio.
   .

Agregar una nueva llave SSH a nuestra cuenta de GitHub

1. Copia el contenido de tu llave publica SSH al portapapeles. Para eso, debes ir a la ubicación de tus llaves “~/.ssh/id_ed25519.pub” y abrir el archivo .pub con el bloc de notas.
   .
2. En GitHub, ve a la esquina superior derecha, da clic en tu imagen de perfil y luego haz clic en Configuraciones.
   
   
   .
3. En la sección “Acceso” de la barra lateral, haz clic en llaves SSH y GPG.
   
   
   .
4. Haz clic en Nueva clave SSH o en Añadir clave SSH.
   .
5. En el campo “Título”, añade una etiqueta descriptiva para la nueva clave. Por ejemplo, si utilizas un portátil personal, puedes llamar a esta clave “Portátil personal”. Selecciona el tipo de clave, ya sea de autenticación o de firma. En el campo “Clave”, pega tu clave pública. Haz clic en Añadir clave SSH.
   
   
   .
6. Si se te solicita, confirma el acceso a tu cuenta en GitHub.

leomarys casi me mata del susto jajajaj

Me saco un sustote el “Freddy Freddy espera”, quiza Freddy si lo esperaba pero yo no JAJAJ

Asi logre solucionar todos los errores que no aparecieron en la clase, espero les ayude.

• Error por nombre de la rama master
• Error para hacer fetch (pull)
• Error en git push (falta de token de acceso personal)

Verificamos que aparece origin para hacer fetch y push

git remote -v

Cambiamos el nombre de nuestra rama master a main

git branch -m master main

Hacemos merge

git config pull.rebase false

Traemos los cambios remotos a local

git pull --allow-unrelated-histories origin main

Creamos un token de acceso personal en Git-Hub.

Click perfil -> Settings -> Developer settings -> Personal access tokens -> Generate new token
Git Hub - creating a personal access token

Subir el repositorio local a Git Hub

git push origin main

Quiero comentar algo, que puede ser muy lógico, pero la verdad me saco canas, dure un día y medio haciendo el proceso de Fredy varias veces e investigue por otras fuentes ya que no me dejaba editar el código en el repositorio, no entendía que era, y resulta que Google traduce la página a español automáticamente, en ultima instancia, suponiendo que no tenia nada que ver, se me dio por desautorizar la traducción y “o sorpresa” pude editar el código con normalidad y crear los comit en el repositorio. Siento que debo compartir esto, ya que esto nos ayuda a entender de la importancia de dominar el ingles y trabajar con nuestros dispositivos en este tipo de idioma…

Amigos, les dejo una manera para poder observar todo el historial de commits desde github:

Usando el sitio web de github:

Haga clic en su proyecto
Haga clic en la pestaña 'Insights’
Haga clic en ‘Red’ o 'Network’
Haga clic en el ‘nodo / círculo’ de cada commit para acceder a su información.

Además, puedes arrastrar la línea de commits para visualizarla entera, en caso que hayan muchos y sobrepase el espacio disponible en pantalla.

Por si alguien tiene error con el user and password al realizar <push>.
Genere un token y solucione el problema. Abajo el procedimeinto.

en tu Git hub sigue esta ruta Settings => Developer Settings => Personal Access Token => Generate New Token =>COPIAR el Token generado. (este sera el “password” para subir los cambios desde la terminal)