Este libro se dirige principalmente desarrolladores y jefes de proyecto así como a los profesionales llamados a modificar código fuente (Diseñadores gráficos, Webdesigner, etc.).

El libro comienza por presentar la historia de las soluciones de gestión de versiones y su interés. Luego permite al lector instalar y configurar Git y utilizarlo a través de cinco capítulos de forma progresiva (funcionamiento de las ramas, compartición de un repositorio, herramientas internas…) Un capítulo permite aprender a utilizar git-flow, un método para gestionar eficazmente las diferentes versiones de un proyecto empresarial.

Los dos últimos capítulos presentan la gestión de versiones de forma práctica utilizando dos escenarios implementados por desarrolladores. El primer escenario toma las bases de uso de Git y muestra el uso de sus principales comandos en un entorno casi real. El segundo escenario presenta un equipo de desarrolladores: desde la instalación de GitLab, hasta un uso del método git-flow por el equipo, este capítulo detalla las principales etapas por las que el equipo debe pasar para versionar un proyecto existente.

Un capítulo presenta una lista de alias y comandos listos para usar, resultado de años de práctica de Git del autor, para que el lector pueda usar Git de manera más efectiva y pueda obtener soluciones a problemas comunes. El último capítulo presenta un caso real de integración continua 100% Git como parte de un desarrollo web con el framework Django.

En el anexo, una guía rápida permite visualizar rápidamente los principales comandos y sus opciones.


¡Nuevo! Rondas de preguntas disponibles con la versión online.

¡Ronda de preguntas
incluida en
la versión online !

• Ponga a prueba sus conocimientos al final de cada capítulo
• Evalúe sus competencias

Descargas

• Descargar los ejemplos del libro (202 Ko)

Prólogo

1. ¿A quién va dirigido este libro?
2. Objetivos del libro
3. Requisitos previos
4. Progresión
5. Detalle de los capítulos
6. Un punto sobre los idiomas
7. Agradecimientos
8. Introducción a Git

Git y la gestión de versiones

1. La gestión de versiones
2. Los beneficios de la gestión de versiones
   1. 1. Una verdadera máquina del tiempo
   2. 2. Una documentación detallada y fechada
   3. 3. Una piedra roseta para colaborar
3. Historia de la gestión de versiones
   1. 1. Sistemas de gestión de versiones locales
   2. 2. Sistemas de gestión de versiones centralizados
   3. 3. Sistemas de gestión de versiones descentralizados
4. ¿Por qué Git?

Instalación de Git

1. Instalación en Linux
   1. 1. Instalación a partir de paquetes preexistentes
   2. 2. Instalación a partir de las fuentes
2. Instalación en Mac OS X
3. Instalación en Windows
4. La ayuda de Git
   1. 1. Aspectos generales
   2. 2. Tipos de comandos Git
      1. a. Los comandos de porcelana
      2. b. Los comandos de fontanería
5. Configuración requerida
   1. 1. Configurar el nombre de usuario
   2. 2. Configurar el e-mail de usuario

Creación de un repositorio

1. Crear un repositorio local
2. El contenido de la carpeta .git
3. El archivo README
4. Markdown
   1. 1. Presentación
   2. 2. Elementos de sintaxis
      1. a. Títulos
      2. b. Listas no ordenadas
      3. c. Listas ordenadas
      4. d. Poner en negrita
      5. e. Poner en cursiva
      6. f. Línea horizontal
      7. g. Código
      8. h. Tablas
      9. i. Enlaces
      10. j. Notas a pie de página
5. RestructuredText
   1. 1. Presentación
   2. 2. Elementos de sintaxis
      1. a. Títulos
      2. b. Listas autonumeradas
   3. 3. Software
6. Herramientas para trabajar con Markdown
   1. 1. Sublime Text
   2. 2. Texts
   3. 3. Ulysses
7. Configurar el repositorio local
   1. 1. Configuración mínima
   2. 2. Niveles de configuración
      1. a. El nivel de sistema
      2. b. El nivel de usuario
      3. c. El nivel repositorio
   3. 3. Los parámetros configurables
      1. a. Definir el editor de texto
      2. b. Modelo de commit
      3. c. Ignorar los archivos
      4. d. Hashs abreviados
   4. 4. Definición de alias Git
8. Las opciones de configuración avanzadas
   1. 1. Paginación
   2. 2. Expresiones regulares extendidas
   3. 3. Separador de palabras
   4. 4. Ancestro común de los conflictos
   5. 5. Configurar la memoria caché de autentificación

Operaciones de archivos y commit

1. Operaciones de archivos y commit
2. Una historia de hash
   1. 1. Una identificación por contenido
   2. 2. Riesgo de colisión
   3. 3. Funcionalidad experimental de hash SHA2-256
3. Las tres zonas de un archivo
   1. 1. El directorio de trabajo
   2. 2. El índice
   3. 3. El repositorio
4. Operar con archivos
   1. 1. Añadir archivos al índice
   2. 2. Mover o renombrar archivos
   3. 3. Borrar archivos
   4. 4. Dejar de seguir un archivo
   5. 5. Ignorar los archivos
5. Commit o guardar los cambios
   1. 1. Efectuar un primer commit
   2. 2. Escribir un buen mensaje de commit
      1. a. Las reglas de un mensaje de commit
      2. b. Método para el título
      3. c. ¿En qué idioma?

Consulta y operaciones del histórico

1. Listar los commits con git log
   1. 1. Limitar el número de commits mostrados
   2. 2. Mostrar las estadísticas
   3. 3. Mostrar cada commit en una sola línea
   4. 4. Filtrar los commits cronológicamente
   5. 5. Filtrar los commits según los participantes
   6. 6. Mostrar el gráfico de las ramas
   7. 7. Especificar un formato de salida
   8. 8. Tener en cuenta los merges
   9. 9. Listar los commits que afectan a un archivo
   10. 10. Mostrar las fechas de manera mas legible
2. Mostrar las diferencias de contenido
   1. 1. Diferencias en curso en el directorio
   2. 2. Diferencias entre el índice y HEAD
   3. 3. Diferencias entre el directorio de trabajo y HEAD
   4. 4. Diferencias introducidas por uno o varios commits
   5. 5. Diferencias de palabras
   6. 6. Ver los bloques de código movidos
3. Identificar al autor de una línea de código
4. Buscar los commits con el modo pick axe
5. Eliminar los cambios en el directorio de trabajo
6. Eliminar las modificaciones del índice
7. Volver a un estado anterior
8. Modificar el último commit
9. Ver un resumen de los commits

Las ramas y los tags

1. Los tags (etiquetas)
   1. 1. Numeración de las versiones
   2. 2. Diferentes tipos de tags
   3. 3. Creación de los tags
   4. 4. Creación de un tag anotado
   5. 5. Lista de tags
   6. 6. Detalles de un tag
   7. 7. Envío de los tags al repositorio remoto
   8. 8. Eliminación de un tag
2. Las ramas (Branch)
   1. 1. Lista de las ramas existentes
   2. 2. Creación de una rama
   3. 3. Posicionamiento en una rama
   4. 4. Fusionar dos ramas
      1. a. El avance rápido
      2. b. Limpiar su repositorio
      3. c. Los conflictos de fusión
   5. 5. Eliminar una rama
   6. 6. Rebasar una rama a otra

Compartir un repositorio

1. ¿Qué es un repositorio remoto?
2. Crear un repositorio remoto
   1. 1. Para un nuevo proyecto
   2. 2. Para un proyecto existente
3. Clonar un repositorio remoto
4. Los protocolos de intercambio
5. Funcionamiento interno y ramas remotas
   1. 1. Los repositorios remotos vinculados
   2. 2. Las ramas remotas seguidas
6. Enviar sus modificaciones
7. Recibir las modificaciones

Git-Flow: workflow de empresa

1. Un sistema de gestión de ramas
   1. 1. Las ramas eternas
      1. a. La rama de producción (master)
      2. b. La rama de desarrollo (develop)
   2. 2. Las ramas efímeras
      1. a. Las ramas de versiones (release)
      2. b. Las ramas de parches (hotfix)
      3. c. Las ramas de funcionalidades (feature)
      4. d. ¿Varios commits en una rama efímera?
2. Ejemplo de workflow
3. Git-Flow intuitivo gracias a Tower
   1. 1. Cliente Git y Git-Flow
   2. 2. Caso práctico de uso

Las herramientas de Git

1. Dejar de lado los cambios con git stash
2. Repositorios integrados con submódulos
   1. 1. Agregar el repositorio integrado
   2. 2. Clonar un repositorio y sus repositorios integrados
   3. 3. Modificación de los repositorios integrados
   4. 4. Eliminar un repositorio integrado
   5. 5. Inconvenientes de los repositorios integrados
3. Recuperar un commit erróneo
   1. 1. Utilización práctica de git bisect
   2. 2. Automatizar git bisect
4. Registro de referencias (reflog)
5. Los hooks
   1. 1. Los diferentes tipos de hooks
   2. 2. ¿Cómo usar los hooks?
   3. 3. Ejemplo de hook: validación de mensajes
   4. 4. Compartir los hooks en el repositorio
6. Las notas Git
   1. 1. Crear una nota
   2. 2. Mostrar las notas
      1. a. Lista de notas
      2. b. Ver las notas de un commit
   3. 3. Editar una nota
   4. 4. Eliminar una nota
   5. 5. Enviar notas al servidor

Escenario de desarrollador independiente

1. Objetivo del capítulo
2. Contexto del escenario
3. Creación de un repositorio
4. Comienzo del desarrollo
5. Guardar las modificaciones
6. Bitbucket
   1. 1. Creación de una cuenta
   2. 2. Enviar un repositorio local a Bitbucket
   3. 3. Editar un archivo en Bitbucket
   4. 4. Recuperar las modificaciones del repositorio remoto
7. Integrar un nuevo desarrollo
   1. 1. Verificar su código antes de la indexación
   2. 2. Hacer commit del nuevo desarrollo
8. Anular las modificaciones de un archivo
9. .gitignore: ignorar una librería
10. Hacer commit de todos los archivos añadidos o modificados
11. Enviar los commits al repositorio remoto
12. Mostrar las diferencias entre dos commits
13. Clonar el repositorio remoto
14. ¿Para qué sirve una rama?
15. Cambiar de rama
16. Fusionar dos ramas

Escenario de equipo

1. Contexto del escenario
2. Resumen del proyecto
   1. 1. Instalación de Python
   2. 2. Recuperación del repositorio
   3. 3. Instalación de las dependencias de Python
   4. 4. Inicialización de los repositorios integrados
   5. 5. Generación de las librerías
   6. 6. Creación del archivo de configuración
   7. 7. Creación de la base de datos
   8. 8. Creación de una cuenta root
   9. 9. Ejecución del servidor
3. Instalación de GitLab
4. Creación de cuentas de usuario
5. Creación del proyecto
6. Asignar los proyectos a los usuarios
7. Primer commit del proyecto
   1. 1. Redacción del archivo .gitignore
      1. a. Ignorar las librerías
      2. b. Ignorar los archivos específicos de la tecnología
      3. c. Ignorar los datos sensibles
      4. d. Agregar los repositorios integrados
      5. e. El archivo README
   2. 2. Commit del proyecto
   3. 3. Creación de la rama develop para Git-Flow
8. Fase de desarrollo
   1. 1. Funcionalidad gráfica
   2. 2. Parche del tiempo negativo
   3. 3. Integración del parche
   4. 4. Funcionalidad de tipo tarea
   5. 5. Finalización de los gráficos
   6. 6. Finalización de los tipos de tarea
   7. 7. Creación de la rama de la versión
   8. 8. Export CSV
   9. 9. Parche de versión
   10. 10. Nueva versión estable
   11. 11. Finalización del export CSV
9. Puesta en línea del repositorio en GitHub
   1. 1. Creación de una cuenta GitHub
   2. 2. Creación de un repositorio
   3. 3. Agregar el repositorio remoto al local
   4. 4. Envío de las ramas
   5. 5. El archivo LICENSE
   6. 6. El archivo README

Máxima productividad con Git

1. Alias listos para usar
   1. 1. Alias simples
      1. a. git last
      2. b. git aa
      3. c. git bv
      4. d. git ba
      5. e. git bd
      6. f. git bdp
      7. g. git ca
      8. h. git cb
      9. i. git cmf
      10. j. git co
      11. k. git di
      12. l. git dc
      13. m. git mnff
      14. n. git st
      15. o. git tg
      16. p. git pu
      17. q. git ss
      18. r. git ssu
      19. s. git sr
      20. t. git srp
      21. u. git sl
      22. v. git sp
      23. w. git sa
      24. x. git sd_f
      25. y. git sb
      26. z. git na
      27. aa. git nl
      28. ab. git napp
      29. ac. git ne
      30. ad. git ns
      31. ae. git nr
      32. af. git ready
   2. 2. Alias complejos
      1. a. git bnew
      2. b. git bold
      3. c. git ll
      4. d. git ld
      5. e. git ls
      6. f. git ln
      7. g. git slv
      8. h. git np
      9. i. git bvn
      10. j. git churn
      11. k. git srr
      12. l. git spr
      13. m. git sar
      14. n. git sdr
   3. 3. Recuperar los alias en GitHub
2. Comandos listos para usar
   1. 1. Comandos relacionados con la configuración
      1. a. Archivo de configuración activo para unaopción
      2. b. Mostrar su configuración
      3. c. Editar fácilmente un nivel de configuración
   2. 2. Comandos de visualización
      1. a. Mostrar los datos técnicos de un commit
      2. b. Mostrar los padres de los commits
      3. c. Mostrar archivos en conflicto
      4. d. Mostrar la lista de archivos modificados
      5. e. Mostar el ancestro común
      6. f. Mostrar el primer commit de una rama
      7. g. Usar git show ocultando el diff
      8. h. Verificar una rama en un repositorio remoto
      9. i. Fusionar ramas sin un ancestro común
      10. j. Mostrar los repositorios remotos y su enlace externo
      11. k. Mostrar los archivos modificados por un commit
      12. l. Mostrar la ruta del repositorio versionado
      13. m. Consultar el histórico de los comandos git
      14. n. Mostrar el número de commits por autor
      15. o. Mostrar el número de commits de un autor
      16. p. Mostrar la última fecha de modificaciónde las ramas
      17. q. Listar las ramas que contienen un commit específico
      18. r. Mostrar el histórico con los diff
      19. s. Buscar un texto/regex en los commits
      20. t. Buscar un texto/regex en los stash
      21. u. Listar los commits de las ramas
      22. v. Comparar un archivo anterior
      23. w. Mostrar ramas ya fusionadas en master
      24. x. Listar las ramas no fusionadas en master
      25. y. Listar los commits de una rama no fusionada en master
   3. 3. Comandos de manipulación
      1. a. Eliminar o revertir cambios en un commit
      2. b. Eliminar del repositorio los archivos ya eliminadosdel proyecto
      3. c. Eliminar cambios del índice
      4. d. Recuperar el archivo de otro commit
      5. e. Eliminar archivos no seguidos del directorio
      6. f.  Eliminar las modificaciones de los archivosseguidos
      7. g. Eliminar una rama distante

Git en implementación continua

1. Objetivos del capítulo
2. El proyecto
3. Presentación de Django
4. Desarrollo de la versión inicial
   1. 1. Instalación
   2. 2. Creación del proyecto
      1. a. Creación del proyecto Django
      2. b. Creación del archivo .gitignore
      3. c. Registro de bibliotecas de Python
      4. d. Primer commit
   3. 3. Creación de aplicaciones de usuarios y artículos
   4. 4. Creación de modelos Django
      1. a. El modelo BaseModel
      2. b. El modelo User
      3. c. El modelo Article
   5. 5. Implementación del módulo de administración
      1. a. Iniciar el servidor de desarrollo
      2. b. Creación de las páginas de usuario
      3. c. Templates principales
      4. d. Lista de los artículos
      5. e. Página de consulta de un artículo
      6. f. Página "Quiénes somos"
5. Implementación inicial
   1. 1. Configuración de los identificadores SSH
   2. 2. Creación de un sitio web Webfaction
   3. 3. Creación de las aplicaciones Webfaction
   4. 4. Creación de la base de datos
   5. 5. Externialización del repositorio de la configuración
   6. 6. Preparar la carpeta del proyecto y crear el repositorio
   7. 7. Configuración del repositorio para la implementaciónautomatizada
   8. 8. Configuración del remote y primer push
   9. 9. Creación del entorno virtual
   10. 10. Configuración de Apache
   11. 11. Envío de la configuración de producción
   12. 12. Ejecutar las migraciones
   13. 13. Sincronizar los archivos estáticos
   14. 14. Reiniciar Apache
6. Implementación automatizada
   1. 1. Desarrollo de hook en el repositorio
   2. 2. Configuración del repositorio remoto
7. Funcionalidad: campo WYSIWYG para el artículo
   1. 1. Desarrollo
   2. 2. Implementación automatizada

Guía rápida

1. Las referencias
   1. 1. HEAD
   2. 2. Las ramas
   3. 3. Los tags (etiquetas)
   4. 4. Referencia a ancestros
2. Los comandos
   1. 1. git add
   2. 2. git archive
   3. 3. git bisect
   4. 4. git blame
   5. 5. git branch
   6. 6. git checkout
   7. 7. git cherry-pick
   8. 8. git clean
   9. 9. git clone
   10. 10. git commit
   11. 11. git config
   12. 12. git diff
   13. 13. git fetch
   14. 14. git gc
   15. 15. git help
   16. 16. git init
   17. 17. git log
   18. 18. git merge
   19. 19. git mv
   20. 20. git pull
   21. 21. git push
   22. 22. git rebase
   23. 23. git reflog
   24. 24. git remote
   25. 25. git reset
   26. 26. git revert
   27. 27. git rm
   28. 28. git show
   29. 29. git stash
   30. 30. git submodule
   31. 31. git tag