CURSO DE GIT Y DE GITHUB

1) En la terminal (o Git Bash, en Windows) navega hasta la carpeta recién

creada (usa el comando cd para navegar entre carpetas);
2) Ejecuta el comando git add index.html para marcar el archivo para ser
guardado (commiteado);
3) Ejecuta git status y verifica que el archivo haya cambiado de estado y esté
listo para ser guardado (commiteado);
4) Después de agregarlo, ejecuta el comando git commit -m "Creando
archivo index.html con lista de cursos". Puedes cambiar el mensaje
de commit si quieres;
5) Cambia el archivo index.html. Agrega el acento en "Integración continua",
por ejemplo;
6) Agrega el archivo a guardar con git add .;
7) Ejecuta el comando git commit -m "Acento agregado en el curso de
Integración Continua". Puedes cambiar el mensaje de commit si quieres;
8) Ejecuta el comando git log y analiza su salida. También ejecuta git log
--oneline, git log -p y otras alternativas que desees probar;
9) Crea un archivo vacío con el nombre que desees, por ejemplo, ide-config;
10) Crea el archivo .gitignore y agrega una línea con el nombre del archivo
recién creado (ide-config, en el ejemplo anterior);
11) Ejecuta git status y verifica que el archivo ide-config no esté en la lista
para ser agregado;
12) Agrega (con git add .gitignore) y confirma (con git commit -m
"Adding .gitignore") el archivo .gitignore.

En esta aula aprendimos:

 Que un commit es la forma de guardar un estado o versión de nuestro
código;
 Cómo agregar archivos para commitear con git add;
 Cómo commitear archivos usando el comando git commit;
 Cómo verificar el historial de commits, a través de git log y algunas de sus
opciones:
o git log --oneline
o git log -p
o git log --pretty="parámetros de formato"
 Cómo hacer que Git no monitoree archivos, a través de .gitignore
 Que no debemos realizar commits, es decir, guardar un estado, de nuestra
aplicación que no esté funcionando.
ALGUNOS COMANDOS

Cd .. accedes a al archivo anterior.

Mkdir crea una nueva carpeta

Cd nombre de la carpeta / accede a una carpeta

Git init –bare para hacer una ruta para el repositiorio que crearé

Git remote add nombre del servidor, luego se coloca la ruta realizada con el git init –bare

Se crea el servidor locar

Git remove –v muestra tanto el fetch como push

Git clone /c/Users/Donaldo/Documents/git-y-github/Servidor/

Proyecto(ruta con la caperta a colocar)
Ls: para ver los archivos dentro dela carpeta
Git push: empuja el archivo a el servidor
Git pull: halar el archivo a el servidor

Ha llegado el momento de que pongas en práctica lo visto en clase. Para hacer

esto, sigue los pasos que se enumeran a continuación.

1) Cree una nueva carpeta en su computadora;

2) En la terminal (o Git Bash, en Windows) navega hasta la carpeta recién

creada (use el comando cd para navegar entre carpetas);
3) Ejecuta el comando git init --bare;

4) Navega hasta la carpeta donde se encuentra tu proyecto;

5) Ejecuta el comando git remote add servidorlocal {ruta}.

Reemplaza {ruta} con la ruta completa de la carpeta recién creada;

6) Crea una nueva carpeta en tu computadora, para representar el trabajo de otra

persona;

7) En la terminal (o Git Bash, en Windows) navega hasta la carpeta recién

creada;
8) Ejecuta el comando git clone {ruta} proyecto. Reemplaza {ruta} con
la ruta completa a la carpeta que creamos en el primer paso;
9) Ten en cuenta que el repositorio clonado está vacío;

10) Accede a la carpeta del Proyecto y ejecuta el comando git remote rename

origin servidorlocal para cambiar el nombre del repositorio local de la otra
persona de "origin" a "servidorlocal";

11) Navega a la carpeta donde se encuentra tu proyecto original;

12) Ejecute el comando git push servidorlocal master para enviar tus

cambios a tu servidor;

13) Navega hasta la carpeta creada en el paso 6;

14) Ejecuta el comando git pull servidorlocal master para descargar los

cambios;
15) Abre tu navegador y vé a http://github.com/;

16) Crea una cuenta;

17) Crea un nuevo repositorio haciendo clic en el símbolo más (+) en la esquina
superior derecha;

18) En la terminal (o Git Bash, en Windows) agrega el repositorio remoto recién

creado a tu proyecto inicial (los comandos los muestra el propio GitHub);
19) Ejecuta git push origin master para enviar tus cambios al repositorio en
GitHub.

En esta aula aprendimos:

 Lo que son los repositorios remotos
 Cómo crear un repositorio de Git sin una copia de los archivos (con --bare)
para usar como servidor;
 Cómo agregar links a repositorios remotos, con el comando git remote
add;
 Cómo descargar un repositorio por primera vez clonándolo con el
comando git clone;
 Cómo enviar nuestros cambios a un repositorio remoto, con git push;
 Cómo actualizar nuestro repositorio con los datos en el repositorio remoto,
usando git pull;
  Qué es GitHub y para qué sirve;
 Cómo crear un repositorio en GitHub;
 Cómo agregar un repositorio de GitHub como repositorio remoto.

Ha llegado el momento de que pongas en práctica lo visto en clase. Para hacer

esto, sigue los pasos que se enumeran a continuación.
1) Ejecute el comando git branch y ve que solo existe la rama master en tu
repositorio;
2) Ejecuta el comando git branch titulo e inmediatamente después ejecuta el
comando git branch. Ve que se creó una nueva rama;
3) Ahora, para comenzar a trabajar en esta rama, escribe git checkout
titulo;
4) Ejecuta git branch nuevamente y verifica que ahora te encuentras en la rama
llamada titulo;
5) Cambia el título de la página index.html a "Cursos de DevOps de Alura";
6) Agrega los cambios con git add index.html;
7) Haz el commit con git commit -m "Cambiando el título de la
página";
8) Ejecuta el comando git log y verifica el nuevo commit;

9) Cambia el título de la página a "Lista de cursos de DevOps de Alura";

10) Repite los pasos 6 y 7, para agregar un nuevo commit, cambiando el mensaje;

11) Repite el paso 8 para verificar el nuevo commit;
12) Ejecuta el comando git checkout master para volver a la línea de
desarrollo master;
13) Ejecuta git log para verificar que los dos últimos commits no estén ahí.
Comprueba que el contenido de tu archivo también ha vuelto a su estado original;

14) En la carpeta creada para representar el trabajo de otra persona en la clase

anterior:

 Ejecuta git checkout -b lista para crear una nueva branch,

llamada lista y comienza a trabajar en ella;
 Agrega el curso "Kubernetes" a la lista;
  Repite los pasos 6 y 7 para agregar un nuevo commit, cambiando el mensaje;
 Ejecuta el comando git checkout master para volver a la línea de
desarrollo master;

15) Regresa a la carpeta que representa tu propio trabajo;

16) Cambia el nombre del curso de Docker a "Docker: Creando contenedores sin
dolor de cabeza";

17) Repite los pasos 6 y 7 para agregar un nuevo commit, cambiando el mensaje;

18) Ejecuta el comando git merge titulo para traer el trabajo realizado en la
branch título a la branch master;
19) Ejecuta el comando git log --graph para ver las líneas de desarrollo
(branches);
20) Ejecuta git checkout titulo para trabajar en la branch llamada titulo;

21) Cambia el título para que tenga la palabra "Cursos" en mayúscula;

22) Repite los pasos 6 y 7 para agregar un nuevo commit, cambiando el mensaje;

23) Ejecuta el comando git checkout master para volver a la línea de
desarrollo master;
24) Ejecuta el comando git rebase titulo;
25) Ejecuta el comando git log y verifica que el commit se agregó antes
del commit realizado directamente en la branch master;
26) Ejecuta el comando git push servidorlocal master para enviar tus
cambios al repositorio remoto que creamos en la última clase;

27) En la carpeta creada para representar el trabajo de otra persona en la clase

anterior:

 Ejecuta el comando git pull servidorlocal master para descargar los

cambios que ya has realizado;
 Ejecuta el comando git checkout lista para continuar trabajando en la
lista de cursos;
 Cambia el nombre del curso de Docker a "Curso de Docker: Creación de
contenedores sin dolor de cabeza";
 Repite los pasos 6 y 7 para agregar un nuevo commit, cambiando el mensaje;
 Ejecuta el comando git checkout master para volver a la línea de
desarrollo master;
  Intenta juntar tu trabajo con git merge lista;
 Observa que hay conflictos. Corrígelos, dejando solo la línea con el nombre
correcto del curso;
 Ejecuta el comando git add index.html para informar que los conflictos
en este archivo se han solucionado;
 Ejecuta el comando git commit para que Git complete el merge;
 Ejecuta el comando git push servidorlocal master para enviar tus
cambios;

28) Regresa a la carpeta que representa tu propio trabajo;

29) Cambia el nombre del curso de Vagrant a "Vagrant: Gerenciando máquinas

virtuales";

30) Repita los pasos 6 y 7 para agregar un nuevo commit, cambiando el mensaje;

31) Intenta ejecutar el comando git push servidorlocal master. Observa la
falla;
32) Ejecuta el comando git pull servidorlocal master para traer los
cambios de la otra persona;
33) Ahora si, ejecuta el comando git push servidorlocal master para
enviar los cambios.

En este aula aprendimos:

 Que una branch (o rama) es una línea de commits separada, y que se puede
usar para desarrollar funcionalidades independientes;
 Que con branches separadas, podemos evitar que el código de una
funcionalidad interfiera con otra;
 Cómo traer el trabajo realizado en una branch a otra branch, como
la master, usando el comando git merge;
 Que git merge genera un nuevo commit, informando que hubo una mezcla
entre dos branches;
 Cómo traer commits de una branch a otra con git rebase
 Que git rebase no genera un commit de merge, lo que simplifica
nuestro log;
 Cómo presenta Git los conflictos;
 Cómo resolver conflictos y conservar sólo los cambios deseados con Git.
Con el git restore deshacemos una modificación que aún no fue agregada
al index o stage, o sea, antes de hacer git add. Después de agregar con git add, para
deshacer una modificación, necesitamos sacarlo de este estado, con git restore --
staged. Ahora, si ya hicimos el commit, el comando git revert puede salvarnos.

Vimos cómo podemos utilizar git stash para almacenar temporalmente

algunas de nuestras modificaciones.
¿En qué momento el stash es útil?
Cuando necesitamos pausar el desarrollo de alguna funcionalidad, o corrección, antes de
finalizar, y tal vez no sea interesante realizar un commit, pues nuestro código puede no estar
funcionando aún. En este caso es interesante guardar el trabajo para poder volver a él
después.

Ha llegado el momento de que pongas en práctica lo visto en clase. Para hacer

esto, sigue los pasos que se enumeran a continuación.
1) En la carpeta que está tu proyecto, realiza cualquier cambio en el
archivo index.html;
2) Ejecuta git status y va que hay un cambio para agregar;
3) Ejecuta el comando git checkout - index.html. Verifica si tu cambio se
ha deshecho;
4) Nuevamente, realiza algunos cambios en el archivo index.html;
5) Ejecuta el comando git add index.html;
6) Ejecuta el comando git reset HEAD index.html para devolver el
archivo index.html al HEAD del proyecto (elimínalo del stage, que es lo que será
enviado para el commit);

7) Repite el paso 3;

8) Vuelve a realizar un cambio en el código;

9) Ejecuta el comando git add index.html y el comando git commit -m

"Cambiando el código" para realizar un commit;
10) Ejecuta el comando git log y copia el hash de este commit recién creado;
11) Ejecuta el comando git revert {hash}, reemplazando {hash} con el hash
que copiaste anteriormente;

12) Verifica que tus cambios se hayan deshecho;

13) Cambia el nombre del curso de Ansible a "Ansible: Infraestructura como
código";

14) Ejecuta el comando git stash para guardar estos cambios en el stash;

15) Cambia el nombre del curso de Kubernetes a "Kubernetes: Introducción a la

orquestación de containers";

16) Ejecuta el comando git add index.html y el comando git commit -m

"Cambiar el nombre del curso de Kubernetes" para realizar un commit;
17) Ejecuta el comando git stash pop para que aparezca el último cambio en
el stash;
18) Ejecuta el comando git add index.html y el comando git commit -m
"Cambiar el nombre del curso Ansible" para realizar un commit;
19) Ejecuta el comando git push servidorlocal master para enviar todos
tus cambios;
20) Ejecuta el comando git log --oneline para ver los commits de forma
resumida. Copia el hash del commit de merge con la branch lista;
21) Ejecuta el comando git checkout {hash} reemplazando {hash} con el
hash que copiaste;

22) Ve que varios cambios ya no están más presentes;

23) Ejecuta git checkout master para volver a la línea de desarrollo principal.

En esta aula aprendimos:

 Que Git puede ayudarnos a deshacer cambios que no vamos a utilizar;
 Que, para deshacer un cambio antes de agregarlo para commit(con git
add), podemos usar el comando git restore <archivos>;
 Que, para deshacer un cambio después de agregarlo para commit, primero
debemos ejecutar git restore --staged <archivos> y luego podemos
deshacerlos con git restore <files>;
  Que, para revertir los cambios realizados en un commit, el comando git
revert puede ser la solución;
 Que el comando git revert genera un nuevo commit informando que los
cambios fueron deshechos;
 Que, para guardar un trabajo y reanudarlo más tarde, podemos usar git
stash;
 Que, para ver qué cambios hay en el stash, podemos usar el comando git
stash list;
 Que, con el comando git stash apply <número>, podemos aplicar un
cambio específico al stash;
 Que el comando git stash drop <número> elimina un elemento
determinado del stash;
 Que el comando git stash pop aplica y elimina el último cambio que se
agregó alstash;
 Que git checkout sirve para dejar la copia del código de nuestra
aplicación en el estado que queremos:
o git checkout <branch> deja el código en el estado de
una branchcon el nombre <branch>;
o git checkout <hash> deja el código en el estado de commit con el
hash <hash>.

Ha llegado el momento de que pongas en práctica lo visto en clase. Para hacer

esto, sigue los pasos que se enumeran a continuación.
1) Ejecuta el comando git log -p para ver, junto a cada commit, los cambios
realizados;
2) Ahora ejecuta el comando git log --oneline;
3) Ejecuta el comando git diff {hash del commit de merge con
lista} .. {hash del último commit realizado};
4) Realiza algún cambio (pequeño) en index.html;
5) Ejecuta el comando git diff y ve este cambio;

6) Deshaga este último cambio;

7) Ejecute el comando git tag -a v0.1.0 para crear un tag en tu código;

8) Ejecuta el comando git push origin v0.1.0 para enviar este tag a
GitHub;
9) Abre la página del repositorio de GitHub que creaste y verifica la
pestaña Releases.
En esta clase aprendemos:
 Que es posible ver qué cambios se hicieron en cada archivo, con el
comando git diff;
 Que, al escribir sólo git diff, vemos los cambios en nuestros archivos que
no se agregaron para commit (con git add);
 Que es posible comparar cambios entre dos ramas con git diff
<branch1> .. <branch2>
 Que es posible comparar los cambios realizados entre un commit y otro,
usando el comando git diff <commit1> .. <commit2>;
 Que Git nos permite guardar “marcos” de nuestra aplicación, por ejemplo,
generando versiones, a través de git tag;
 Que el comando git tag -a se usa para generar una nueva tag;
 Las Releases de GitHub, que son generadas para cada tag de Git que
creamos en nuestro repositorio.