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.

_Resumen _

A seguir aprendiendo! 😃

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:

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.

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!

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 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.

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

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

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.

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:

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

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.

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

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

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

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)

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.

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

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

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

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!

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

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.

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.

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.

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…

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 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

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.

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

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

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.

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

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

![](

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.

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

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 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

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

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

Otra manera de solucionar el error de las ramas

Es ir a la opción de Branch en GitHub

Y cambiar el main por master

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…

Seria bueno hacer un curso de GitHub actualizado ya que han cambiado muchas cosas y es fácil perderse, como el echo de que ya no pide contraseña sino token o el master por el main … cosas así

al momento de tener que ingresar tu cuenta y password NO ES TU NOMBRE DE USUARIO, si no tu correo de github y el PASSWORD es el TOKEN que debes de generar NO TU PASSWORD DE la cuenta de GITHUB.

para generar el token es :
1.- ve a settings
2.- ve hasta abajo busca DEVELOPER SETTINGS del lado izquierdo.
3.- ve a: personal acces tokens.
4.- Busca: generate new token
5.- en NOTE escribe como se llamara el token, yo digite gen_newtoken (no importa el nombre hasta donde yo se)

nota : en expiration podras tu seleccionar cuantos dias estara activo el token, tu decides.

6.- selecciona REPO y nada mas.
7.- y ve hasta abajo y da click en el boton GENERATE TOKEN.

8.- copia el token y OJO pegalo en bloc de notas.

ahora podras usar el password como tu token. tenlo a la mano. para no generar nuevo tokens.

saludos.

CUIDADO:

Desde el 2021 a Github ya no le basta tu usuario y contaseña para conectar tu repositorio con tu git local. Ahora es obligatorio crear una clave especial (o token) que permita la conexión entre git y github.
Si al poner tu password y tu usuario te sale esto:

Es porque no has configurado tu clave ssh o token.

¿Cómo hacer esto? (Configurar clave ssh personal)

1. Creas tu llave ssh y la conectas con tu cuenta de github
   (Aquí como hacerlo en windows y aquí como hacerlo en linux, ambas clases de sus respectivos cursos de prework)
2. En vez de copiar con “Clone with HTTPS” en github (Lo que hace Freddy al minuto 5:15), pones la opción “SSH” y usas esta en tu

git remote add origin "opcion_SSH"

1. Listo!
   Ahora cuando hagas tu “git push” no te debería de salir el error ni pedirte tu usuario y clave.

Bonus:

Si recién ves este comentario y ya habías hecho lo que dijo Freddy, solo debes poner:

code .git/config

y cambiar la url de allí (La que esta en HTTPS) y cambiarla por la de SSH.
Guardas y listo!
Continúa aprendiendo. ;D

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 no esta actualizado

Es posible que en este momentos todos estemos enterados que para acceder al API de GitHub desde la terminal/bash necesitamos un token, si tienen dudas pueden seguir este enlace.

Pero hay un inconveniente, y es que cada vez que queremos hacer alguna actualización al repositorio debemos ingresar el nombre de usuario de Git y el Token

Para solucionarlo y no tener que hacerlo, escribimos en la terminal lo siguiente

git config --global credential.helper cache

nos pedira una última vez el usuario y token, y ya está.

En caso que quieran eliminar esa configuración porque cambiaron de usuario y/o actualizaron el token, entonces hacen lo siguiente:

git config --global unset credential.helper

Para aquellos que están después de agosto 13 de 2021 y les aparece esto:

tienen que hacer lo siguiente, en su cuenta de github ir a configuración:

Después ir a “Developer settings”:

Y ahí seleccionar “personal access tokens” :

Darle a :

y marcar las condiciones que le sirvan a tu repositorio, cuando te de el token lo copias y lo pones en la consola

MI APORTE: DESDE EL 13 DE JULIO DEL 2021 YA BNO TE PERMITE AUTTENTIFICARTE CON PASSWORD Y CONTRASÑEA, EN VEZ DE ESO , DEBES GENERAR UN TOKEN :
ACÁ ESTÁ LA GUIA COMO HACERLO : https://docs.github.com/en/authentication/keeping-your-account-and-data-secure/creating-a-personal-access-token

GIT HUB CAMBIO EL SISTEMA DE AUTENTIFICACION.
Cuango use le comando (git push origin master), les va a edir su usuario.
Hasta ahi todo ok, pero el password no tiene que poner el de su cuenta de GitHub, ahora deben usar un token (llave).
Es mas facil de lo que suena.
en la pagina de GitHub desplegar el menu que esta en la flechita al lado del su imagen de perfil.
luego siguen la siguiente ruta.

• Settings

• Developer settings

• Personal access tokens

• Generate new token

Ahora que estas ahi:

• En “note” le pones algo para recordar para que vas a usar ese token.

• En Expiration seleccionas el timpo que quieres que este vivo ese token, si es de uso personal yo le pondria sin expiracion.

• En lienas que siguen seleccionas los permisos que va a tener ese token, otra vez, si es uso personal ponele todo.

• Despues de todo le das click a “Generate Token”

Listo ya tinenes tu token solo falta copiarlo y usarlo en logar de tu password.
De ahora en mas cuando estes haciendo algo desde la consola con GitHub deberas usar este token en lugar del password.

Si estás haciendo el curso luego de Agosto 2021, al hacer el git push origin master, si trabajas con Mac, cuando ingreses tu mail y contraseña te saldrá este mensaje: "Support for password authentication was removed on August 13, 2021. Please use a personal access token instead"
Lo que se debe hacer es generar un token, en lugar de ingresar la contraseña del usuario de github y para esto debemos seguir los siguientes pasos:

• Ir hasta nuestro perfil en Github y hacer click sobre nuestra foto de perfil. Ahí elegir la opción settings
• Elegir developer settings y luego Personal Access tokens
• Una vez ahí, le das Generate new token y le agregas una breve descripción
• Luego eliges un período de vigencia del token (no se recomienda que sea ilimitado)
• Finalmente asignar permisos como repo y la opción de admin repo (para el manejo de repositorios) y luego generar token

Una vez generado el token, lo ingresas cuando te pide la contraseña y listo, ya se completa tu primer push!

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.

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 😃

Cuando intente hacer el comando “git push origin master:main” me apareció eso, creo que es un actualización de git para mas seguridad

pide que se cree un token de autenticacion, van a github y en “settings”> “developer settings” y buscan el botón que dice “personal access token” dar clik y habrá una opción de generar un token de acceso personal, le tienen que dar un nombre y una fecha de expiración, también tienen que darle alcances y permisos, hay una casilla que dice “REPO” se activa y esa es la que permite logearse con github, después dan clik en generar token y les saldrá una especie de código que tienen que guardar ya que solo se puede generar un vez. ya que tengan el token pueden seguir con los comandos, solo que en lugar de colocar el password colocan el token que se genero.

tambien pueden buscar en google como generar un token personal en github y ahí esta de manera mas grafica… espero poder ayuda a alguien

Responder

Buenas noches compañeros, haciendo este curso me dí cuenta que ya no es posible acceder a GitHub desde la terminal simplemente con las credenciales de usuario y contraseña.

Ahora se debe crear un PAT o Token de Acceso Personal desde la plataforma de GitHub, y utilizar este en cambio de la contraseña de nuestro usuario para poder ejecutar los comandos de push o pull y en general para conectarse con el repositorio remoto.

A continuación, adjunto el enlace con la información que me ayudó a mí con este inconveniente.

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

Espero les sirva chicos, saludos

Esta lección ha sido todo un reto para mí. Me ha costado bastante tiempo interiorizarla y superar algunos inconvenientes, pero gracias a Dios se pudo aprender. Muy importante tener atención en la parte de enviar tu rama master al git remoto ya que se presenta un conflícto de nombres emntre la rama del git local y la rama del git remoto, Aquí comparto mis notas y explico como solucionar ese inconveniente:
l

II

III

Para quienes hacemos el curso en 2022, ahora se necesita crear un token para poder realizar push con nuestros archivos. Esto se hace desde la web de github, settings - Developer settings - Personal acces token , entonces generan el token y lo utilizan como contraseña al realizar un push

Al hacer push; Si al ingresar las credenciales de sus cuentas de github no les reconoce el password (como me pasó a mi) es porque ahora se debe de generar una “Personal access tokens”

Adjunto imagen de los pasos para que puedan generarla

Quisiera mencionar que todo iba realizándolo bien hasta que me encontré que ahora cuando pide ingresar usuario y contraseña, la contraseña no sirve, dado el nuevo sistema de seguridad de GitHub, por ende, buscando encontré que en la página personal de nuestro GitHub debemos ir a:

Settings => Developer Settings => Personal Access Token => Generate New Token y dar los permisos deseados [Yo puse todos].

Una vez generado el token, ese el que se ingresa en contraseña y listo, solucionado!

Dos actualizaciones del video serian:}
1-Se debe ingresar el token y no la clave que entrega github
2-Se debe configurar por defecto en github que el origen siempre sea master

Un archivo README suele ser el primer elemento que verá un visitante cuando entre a tu repositorio. Los archivos README habitualmente incluyen información sobre:

Qué hace el proyecto.
Por qué el proyecto es útil.
Cómo pueden comenzar los usuarios con el proyecto.
Dónde pueden recibir ayuda los usuarios con tu proyecto
Quién mantiene y contribuye con el proyecto.

Si colocas tu archivo README en la raíz de tu repositorio, docs, o en el directorio oculto .github, GitHub lo reconocerá y automáticamente expondrá tu archivo README a los visitantes del repositorio.

git remote add origin ‘url’ para agregar el repositorio remoto
git push origin master para enviar los archivos a la rama master
git pull origin master para traer los cambios del remoto
git pull origin master --allow-unrelated-histories para hacer merge con la rama master de github

GitHub: Es un sitio web que utiliza el sistema de control de de versiones Git
//Entendiendo como funciona la interfaz de GitHub

• Para crear un nuevo repositorio:

1. Hacer click en la parte superior izquierda de la página de inicio, en el icono de “más”; elegir la opción New repository.
2. Completar campos y marcar la opción “Initialize this repository with a README”.

//Llevar nuestro repositorio local al nuestro repositorio remoto de GitHub

1. Ir a nuestro repositorio remoto y copiar su URL de protocolo HTTPS.
2. Dirigirnos al directorio / carpeta de trabajo local.
3. En consola ejecutar el comando:

$ git remote add origin ___________ 
//			                       ^── URL del repositorio remoto 

1. Finalmente, enviar el repositorio local:

$ git push origin master 

// Pueden ocurrir los siguientes problemas:

1. Un error indicando que hay cambios en el repositorio remoto que no están integrados con el repositorio local; ejecutar:

$ git pull origin master // Se está trayendo esos cambios

1. Forzar a Git a fusionar la rama del repositorio remoto (origin) y la rama del repositorio local (master):

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

Comandos de git aprendidos:

• git remote: nos permite ver nuestros repositorios remotos. también podemos agregar -v para ver los detalles, la dirección te nuestro repositorio.

• git remote add origin + url del repositorio: se usa para añadir un repositorio remoto.

-git pull origin master: nos trae lo que tenemos en el repositorio remoto. si agregamos –allow-unrelated-histories: fusiona las historias de nuestros repositorios; es decir, historia de commits.

• git push origin master: envía el master local al master de github.

si algo está mal por favor corregidme.

Bueno mi gente. El cambio de GitHub en las ramas (master --> main) fue un pequeño “dolor de cabeza”.
Lo importante es que se ha logrado superar el obstáculo.
–> Para evitar 2 ramas en GitHub puedes hacer lo siguiente: al crear el repositorio en la web marcar la opción “Choose a License”.

Luego da click en “settings” y te abrirá una nueva pestaña en tu navegador.

Escribe “master” y da click en “update”. Lo tienes, en adelante los nuevos repositorios que crees se crearan por defecto en la rama “master”.

–> La otra opción es que leas la siguiente guía en el blog de Platzi para cambiar en la consola el nombre de la rama “master” por “main”.
Este artículo debería estar previo a esta clase para evitar confusiones:
https://platzi.com/blog/cambios-en-github-master-main/

Tengo el siguiente error al hacer git push origin master:

fatal: unable to access 'https://github.com/username/hyperblog.git/': Could not resolve host: github.com

Leí que puede ser algún problema relacionado con los servidores proxy e intenté estos comandos:

git config --global --unset https.proxy
git config --global --unset https.proxy

pero no tuve éxito. Cualquier ayuda o sugerencia es bienvenida.

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.

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 😃

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 😃