uso de git

Informe GIT

Portal Web Huila Construyendo Mundo

Miguel Ángel Fonseca Castro

Corporación Politécnica Nacional de Colombia - Plantilla de documentos

HISTORIAL DE CAMBIOS

Versión Fecha Sección

Modificada Descripción

cambios Responsable(s)

1.0 06/08/2015 Todo Creación del documento.

Miguel Ángel Fonseca Castro

Tabla 1 Cuadro historial de versiones

Contenido Informe GIT ......................................................................................................................................... 1

HISTORIAL DE CAMBIOS ...................................................................................................................... 2

Título del documento .......................................................................................................................... 2

1. ¿QUÉ ES GIT? ............................................................................................................................... 3

2. Crear el Repositorio de configuraciones ..................................................................................... 4

3. Creando una copia del proyecto ................................................................................................. 4

4. Configurando proyecto en Eclipse .............................................................................................. 5

5. Consolidado de cambios y envíos al repositorio. ........................................................................ 6

6. Envío de Cambios al repositorio del servidor .............................................................................. 8

7. Obteniendo cambios desde el repositorio remoto ................................................................... 12

Título del documento

Informe sobre GIT


1. ¿QUÉ ES GIT?

Git en pocas palabras es un controlador de versiones distribuido. Para ampliar este

significado debemos responder primero la siguiente pregunta. ¿Qué es un controlador de

versiones? Un controlador de versiones es un sistema que registra los cambios en un

archivo o conjunto de archivos a través del tiempo para que se puedan recuperar

versiones específicas de los mismos más adelante.

Ahora, ¿Por qué es distribuido? Cuando los usuarios descargan la última versión de los

archivos no solo están descargando los archivos; sino también realizando una copia fiel y

exacta (copia de seguridad) del repositorio (carpeta donde se alojan estos archivos) de

esta manera si dicho repositorio muere, cualquiera de los usuarios que descargaron estos

archivos pueden restaurar el estado de ese del mismo haciendo uso de su copia de

seguridad. Por otra parte esto permite que se puedan tener varios repositorios remotos

para poder trabajar y colaborar con diferentes grupos de personas al mismo tiempo en un

mismo proyecto, cosa que no es posible con los sistemas centralizados.

Características que destacan de Git como control de versiones:

Fotografías rápidas, NO diferencias - A la hora de guardar la información de varios

archivos, Git toma una fotografía rápida del estado de los mismos y guarda las

referencias de esta fotografía. Luego para ser eficiente revisa los archivos que no

fueron modificados y cambia las referencias de los mismos a su versión anterior.

Casi todas las operaciones son locales - Sí ya descargaste un repositorio no es

necesario estar conectado a una red o conexión a internet para trabajar sobre

archivos, todo lo necesario se encuentra en tu computadora.

Integridad de la data - Git antes de guardar la fotografía del estado de un archivo

realiza un checksum de la data. De esta manera es imposible cambiar el contenido de

cualquier archivo sin que Git lo note.

Git generalmente solo añade data - Al trabajar en cualquier archivo y almacenar los

cambios se está agregando data a la base de datos de Git. Esto nos da la seguridad de

que si estos cambios fueron persistidos es muy difícil que se pierdan.

Trabaja con tres estados - Lo más importante para recordar de Git son los tres(3)

estados en que los archivos residen: consolidada (committed), modificados y en

escenario (stage). Modificado, se han detectado cambios en el archivo pero no se han

consolidado. Consolidado, el archivo y su data han sido guardados satisfactoriamente

en la base de datos de Git. En escenario se han marcado las modificaciones de un

archivo y su próximo paso será consolidar la data.


2. Crear el Repositorio de configuraciones

Ubicado en el servidor donde se almacenará el proyecto, se creará una carpeta que lo contendrá

usando el siguiente comando:

Dentro de la carpeta debemos ejecutar el siguiente comando para iniciar el git que almacenara las

configuraciones, tal como se muestra en la siguiente captura:

3. Creando una copia del proyecto

Desde la maquina local donde se realizará las modificaciones se ejecutará el siguiente comando

para crear un clon de la versión almacenada, desde aquí se empezara a desarrollar la aplicación en

cuestión.

En Windows se utiliza el Bash de Git para acceder inicialmente a la consola.

Y finalmente ubicándonos donde deseamos creamos la copia del proyecto.


4. Configurando proyecto en Eclipse

Agregamos el proyecto de eclipse a través del siguiente botón:

Configuramos el tipo de proyecto que usaremos, en este caso es un proyecto PHP, se seleccionan

las siguientes opciones:


Buscamos la ubicación de la carpeta del proyecto copia y finalizamos:

5. Consolidado de cambios y envíos al repositorio.

Después de haber realizado todas las acciones correspondientes al proyecto, en Eclipse los

cambios se verán de la siguiente manera:


Git en Eclipse manejará diferentes visualizaciones para indicarte que ha habido cambios en los

diferentes archivos del proyecto, los colores más usuales usados son el Verde para indicar que se

ha agregado un nuevo fichero, y Azul para indicar que solo ha sido una modificación.

Todos los cambios inicialmente realizados quedarán almacenados en la base de datos de Git local,

y no se reflejaran en el repositorio hasta que se hayan consolidado, para ello se debe seguir el

siguiente procedimiento.

Se encontrar desde la ubicación donde desea consolidar los cambios, para este ejemplo serán

todas las fuentes del proyecto, por lo cual nos ubicamos en la raíz, y cliqueamos con el botón

derecho del Mouse desplegándose el siguiente menú contextual.


Seleccionamos Git y posteriormente cliqueamos en Commit… donde se nos desplegará la siguiente

ventana:

En este apartado podremos revisar los cambios efectuados, compararlos con el servidor, revertir

cambios. Las únicas configuraciones necesarias son El mensaje para identificar que se está

consolidando (Una breve descripción del cambio), el autor y el usuario que hará la consolidación,

finalmente se procede a dar clic en el botón Commit para consolidar localmente.

6. Envío de Cambios al repositorio del servidor

De nuevo desde eclipse, en la raíz del proyecto, para enviar los cambios consolidados, damos clic

derecho para que se nos despliegue el menú ya anteriormente mostrado, en esta ocasión nos

adentraremos en las opciones de Remote, específicamente en Push…

Como se muestra en la siguiente imagen:


Se nos desplegará la siguiente ventana, desde esta escogeremos el repositorio origen y

proseguimos dando clic en Next


Se nos solicitará los accesos de nuestro servidor, en este caso los usados para la conexión SSH por

ser un servidor Linux y finalizaremos dando clic en OK.


Escogeremos una de la rama local como la del servidor de y a la cual queremos enviar los cambios

consolidados, en este caso sólo se encuentra la Master, por tal razón es la que se selecciona para

poder continuar y finalizar:

Nos aparecerá una alerta de confirmación, aceptamos para que se ejecute el proceso.


7. Obteniendo cambios desde el repositorio remoto

Para obtener cambios efectuados sobre el servicio remoto, desarrollados por ejemplo por otro

compañero de equipo, desde Eclipse nos ubicamos en la raíz del proyecto, damos clic derecho, el

las opciones seleccionamos Git, Remote, Pull

Seleccionamos el servidor repositorio origen y seguimos con el proceso


Y para finalizar seleccionamos la rama de la cual queremos obtener los últimos cambios.

uso de git

Documents