Pro Git Manual


User Manual:

Open the PDF directly: View PDF PDF.
Page Count: 578 [warning: Documents this large are best viewed by clicking the View PDF Link!]

This work is licensed under the Creative Commons Attribution-
NonCommercial-ShareAlike 3.0 Unported License. To view a copy of this li-
cense, visit or send a letter
to Creative Commons, PO Box 1866, Mountain View, CA 94042, USA.
Preface by Scott Chacon
Welcome to the second edition of Pro Git. The first edition was published over
four years ago now. Since then a lot has changed and yet many important
things have not. While most of the core commands and concepts are still valid
today as the Git core team is pretty fantastic at keeping things backward com-
patible, there have been some significant additions and changes in the commu-
nity surrounding Git. The second edition of this book is meant to address those
changes and update the book so it can be more helpful to the new user.
When I wrote the first edition, Git was still a relatively diicult to use and
barely adopted tool for the harder core hacker. It was starting to gain steam in
certain communities, but had not reached anywhere near the ubiquity it has to-
day. Since then, nearly every open source community has adopted it. Git has
made incredible progress on Windows, in the explosion of graphical user inter-
faces to it for all platforms, in IDE support and in business use. The Pro Git of
four years ago knows about none of that. One of the main aims of this new edi-
tion is to touch on all of those new frontiers in the Git community.
The Open Source community using Git has also exploded. When I originally
sat down to write the book nearly five years ago (it took me a while to get the
first version out), I had just started working at a very little known company de-
veloping a Git hosting website called GitHub. At the time of publishing there
were maybe a few thousand people using the site and just four of us working on
it. As I write this introduction, GitHub is announcing our 10 millionth hosted
project, with nearly 5 million registered developer accounts and over 230 em-
ployees. Love it or hate it, GitHub has heavily changed large swaths of the Open
Source community in a way that was barely conceivable when I sat down to
write the first edition.
I wrote a small section in the original version of Pro Git about GitHub as an
example of hosted Git which I was never very comfortable with. I didn’t much
like that I was writing what I felt was essentially a community resource and also
talking about my company in it. While I still don’t love that conflict of interests,
the importance of GitHub in the Git community is unavoidable. Instead of an
example of Git hosting, I have decided to turn that part of the book into more
deeply describing what GitHub is and how to eectively use it. If you are going
to learn how to use Git then knowing how to use GitHub will help you take part
in a huge community, which is valuable no matter which Git host you decide to
use for your own code.
The other large change in the time since the last publishing has been the de-
velopment and rise of the HTTP protocol for Git network transactions. Most of
the examples in the book have been changed to HTTP from SSH because it’s so
much simpler.
It’s been amazing to watch Git grow over the past few years from a relatively
obscure version control system to basically dominating commercial and open
source version control. I’m happy that Pro Git has done so well and has also
been able to be one of the few technical books on the market that is both quite
successful and fully open source.
I hope you enjoy this updated edition of Pro Git.
Preface by Scott Chacon
Preface by Ben Straub
The first edition of this book is what got me hooked on Git. This was my intro-
duction to a style of making soware that felt more natural than anything I had
seen before. I had been a developer for several years by then, but this was the
right turn that sent me down a much more interesting path than the one I was
Now, years later, I’m a contributor to a major Git implementation, I’ve
worked for the largest Git hosting company, and I’ve traveled the world teach-
ing people about Git. When Scott asked if I’d be interested in working on the
second edition, I didn’t even have to think.
It’s been a great pleasure and privilege to work on this book. I hope it helps
you as much as it did me.
To my wife, Becky, without whom this adventure never would have begun. — Ben
This edition is dedicated to my girls. To my wife Jessica who has supported me
for all of these years and to my daughter Josephine, who will support me when
I’m too old to know what’s going on. — Scott
Debido a que este es un libro cuya traducción es “Open Source, hemos recibi-
do la colaboración de muchas personas a lo largo de los últimos años. A contin-
uación hay una lista de todas las personas que han contribuido en la traduc-
ción del libro al idioma español. Muchas gracias a todos por colaborar a mejor-
ar este libro para el beneficio de todos los hispanohablantes.
35 Andrés Mancera
15 Carlos A. Henríquez Q.
4 Dmunoz94
3 Sergio Martell
2 Mario R. Rincón-Díaz
1 Juan Sebastián Casallas
You’re about to spend several hours of your life reading about Git. Let’s take a
minute to explain what we have in store for you. Here is a quick summary of the
ten chapters and three appendices of this book.
In Chapter 1, we’re going to cover Version Control Systems (VCSs) and Git
basics—no technical stu, just what Git is, why it came about in a land full of
VCSs, what sets it apart, and why so many people are using it. Then, we’ll ex-
plain how to download Git and set it up for the first time if you don’t already
have it on your system.
In Chapter 2, we will go over basic Git usage—how to use Git in the 80% of
cases you’ll encounter most oen. Aer reading this chapter, you should be
able to clone a repository, see what has happened in the history of the project,
modify files, and contribute changes. If the book spontaneously combusts at
this point, you should already be pretty useful wielding Git in the time it takes
you to go pick up another copy.
Chapter 3 is about the branching model in Git, oen described as Git’s killer
feature. Here you’ll learn what truly sets Git apart from the pack. When you’re
done, you may feel the need to spend a quiet moment pondering how you lived
before Git branching was part of your life.
Chapter 4 will cover Git on the server. This chapter is for those of you who
want to set up Git inside your organization or on your own personal server for
collaboration. We will also explore various hosted options if you prefer to let
someone else handle that for you.
Chapter 5 will go over in full detail various distributed workflows and how to
accomplish them with Git. When you are done with this chapter, you should be
able to work expertly with multiple remote repositories, use Git over e-mail and
dely juggle numerous remote branches and contributed patches.
Chapter 6 covers the GitHub hosting service and tooling in depth. We cover
signing up for and managing an account, creating and using Git repositories,
common workflows to contribute to projects and to accept contributions to
yours, GitHub’s programmatic interface and lots of little tips to make your life
easier in general.
Chapter 7 is about advanced Git commands. Here you will learn about top-
ics like mastering the scary reset command, using binary search to identify
bugs, editing history, revision selection in detail, and a lot more. This chapter
will round out your knowledge of Git so that you are truly a master.
Chapter 8 is about configuring your custom Git environment. This includes
setting up hook scripts to enforce or encourage customized policies and using
environment configuration settings so you can work the way you want to. We
will also cover building your own set of scripts to enforce a custom committing
Chapter 9 deals with Git and other VCSs. This includes using Git in a Subver-
sion (SVN) world and converting projects from other VCSs to Git. A lot of organi-
zations still use SVN and are not about to change, but by this point you’ll have
learned the incredible power of Git—and this chapter shows you how to cope if
you still have to use a SVN server. We also cover how to import projects from
several dierent systems in case you do convince everyone to make the plunge.
Chapter 10 delves into the murky yet beautiful depths of Git internals. Now
that you know all about Git and can wield it with power and grace, you can
move on to discuss how Git stores its objects, what the object model is, details
of packfiles, server protocols, and more. Throughout the book, we will refer to
sections of this chapter in case you feel like diving deep at that point; but if you
are like us and want to dive into the technical details, you may want to read
Chapter 10 first. We leave that up to you.
In Appendix A we look at a number of examples of using Git in various spe-
cific environments. We cover a number of dierent GUIs and IDE programming
environments that you may want to use Git in and what is available for you. If
you’re interested in an overview of using Git in your shell, in Visual Studio or
Eclipse, take a look here.
In Appendix B we explore scripting and extending Git through tools like lib-
git2 and JGit. If you’re interested in writing complex and fast custom tools and
need low level Git access, this is where you can see what that landscape looks
Finally in Appendix C we go through all the major Git commands one at a
time and review where in the book we covered them and what we did with
them. If you want to know where in the book we used any specific Git command
you can look that up here.
Let’s get started.
Table of Contents
Preface by Scott Chacon iii
Preface by Ben Straub v
Dedications vii
Contribuidores ix
Introduction xi
CHAPTER 1: Inicio - Sobre el Control de Versiones 25
Acerca del Control de Versiones 25
Sistemas de Control de Versiones Locales 26
Sistemas de Control de Versiones Centralizados 27
Sistemas de Control de Versiones Distribuidos 28
Una breve historia de Git 30
Fundamentos de Git 30
Copias instantáneas, no diferencias 31
Casi todas las operaciones son locales 32
Git tiene integridad 33
Git generalmente solo añade información 33
Los Tres Estados 33
La Línea de Comandos 35
Instalación de Git 35
Instalación en Linux 36
Instalación en Mac 36
Instalación en Windows 37
Instalación a partir del Código Fuente 38
Configurando Git por primera vez 38
Tu Identidad 39
Tu Editor 40
Comprobando tu Configuración 40
¿Cómo obtener ayuda? 41
Resumen 41
CHAPTER 2: Fundamentos de Git 43
Obteniendo un repositorio Git 43
Inicializando un repositorio en un directorio existente 43
Clonando un repositorio existente 44
Guardando cambios en el Repositorio 45
Revisando el Estado de tus Archivos 46
Rastrear Archivos Nuevos 47
Preparar Archivos Modificados 48
Estatus Abreviado 49
Ignorar Archivos 50
Ver los Cambios Preparados y No Preparados 51
Confirmar tus Cambios 54
Saltar el Área de Preparación 56
Eliminar Archivos 56
Cambiar el Nombre de los Archivos 58
Ver el Historial de Confirmaciones 59
Limitar la Salida del Historial 64
Deshacer Cosas 66
Deshacer un Archivo Preparado 67
Deshacer un Archivo Modificado 68
Trabajar con Remotos 69
Table of Contents
Ver Tus Remotos 69
Añadir Repositorios Remotos 71
Traer y Combinar Remotos 71
Enviar a Tus Remotos 72
Inspeccionar un Remoto 73
Eliminar y Renombrar Remotos 74
Etiquetado 74
Listar Tus Etiquetas 75
Crear Etiquetas 75
Etiquetas Anotadas 76
Etiquetas Ligeras 76
Etiquetado Tardío 77
Compartir Etiquetas 78
Sacar una Etiqueta 79
Git Aliases 79
Resumen 81
CHAPTER 3: Ramificaciones en Git 83
¿Qué es una rama? 83
Crear una Rama Nueva 86
Cambiar de Rama 87
Procedimientos Básicos para Ramificar y Fusionar 91
Procedimientos Básicos de Ramificación 91
Procedimientos Básicos de Fusión 96
Principales Conflictos que Pueden Surgir en las Fusiones 98
Gestión de Ramas 101
Flujos de Trabajo Ramificados 103
Ramas de Largo Recorrido 103
Ramas Puntuales 104
Ramas Remotas 107
Publicar 112
Table of Contents
Hacer Seguimiento a las Ramas 114
Traer y Fusionar 116
Eliminar Ramas Remotas 116
Reorganizar el Trabajo Realizado 117
Reorganización Básica 117
Algunas Reorganizaciones Interesantes 120
Los Peligros de Reorganizar 122
Reorganizar una Reorganización 125
Reorganizar vs. Fusionar 127
Recapitulación 127
CHAPTER 4: Git en el Servidor 129
The Protocols 130
Local Protocol 130
The HTTP Protocols 131
The SSH Protocol 134
The Git Protocol 134
Configurando Git en un servidor 135
Colocando un Repositorio Vacío en un Servidor 136
Pequeñas configuraciones 137
Generating Your SSH Public Key 138
Setting Up the Server 139
Git Daemon 142
Smart HTTP 144
GitWeb 145
GitLab 148
Installation 148
Administration 149
Basic Usage 152
Working Together 152
Third Party Hosted Options 153
Table of Contents
Resumen 153
CHAPTER 5: Distributed Git 155
Distributed Workflows 155
Centralized Workflow 155
Integration-Manager Workflow 156
Dictator and Lieutenants Workflow 157
Workflows Summary 158
Contributing to a Project 159
Commit Guidelines 159
Private Small Team 161
Private Managed Team 168
Forked Public Project 174
Public Project over E-Mail 178
Summary 181
Maintaining a Project 181
Working in Topic Branches 182
Applying Patches from E-mail 182
Checking Out Remote Branches 186
Determining What Is Introduced 187
Integrating Contributed Work 188
Tagging Your Releases 195
Generating a Build Number 196
Preparing a Release 197
The Shortlog 197
Summary 198
CHAPTER 6: GitHub 199
Account Setup and Configuration 199
SSH Access 200
Your Avatar 202
Table of Contents
Your Email Addresses 203
Two Factor Authentication 204
Contributing to a Project 205
Forking Projects 205
The GitHub Flow 206
Advanced Pull Requests 214
Markdown 219
Maintaining a Project 224
Creating a New Repository 224
Adding Collaborators 226
Managing Pull Requests 228
Mentions and Notifications 233
Special Files 237
Project Administration 238
Managing an organization 240
Organization Basics 240
Teams 241
Audit Log 243
Scripting GitHub 244
Hooks 245
The GitHub API 249
Basic Usage 250
Commenting on an Issue 251
Changing the Status of a Pull Request 252
Octokit 254
Summary 255
CHAPTER 7: Git Tools 257
Revision Selection 257
Table of Contents
Single Revisions 257
Short SHA-1 257
Branch References 259
RefLog Shortnames 260
Ancestry References 261
Commit Ranges 263
Interactive Staging 266
Staging and Unstaging Files 266
Staging Patches 269
Stashing and Cleaning 270
Stashing Your Work 270
Creative Stashing 273
Creating a Branch from a Stash 274
Cleaning your Working Directory 275
Signing Your Work 276
GPG Introduction 277
Signing Tags 277
Verifying Tags 278
Signing Commits 279
Everyone Must Sign 281
Searching 281
Git Grep 281
Git Log Searching 283
Rewriting History 284
Changing the Last Commit 285
Changing Multiple Commit Messages 285
Reordering Commits 288
Squashing Commits 288
Splitting a Commit 290
The Nuclear Option: filter-branch 291
Reset Demystified 293
Table of Contents
The Three Trees 293
The Workflow 295
The Role of Reset 301
Reset With a Path 306
Squashing 309
Check It Out 312
Summary 314
Advanced Merging 315
Merge Conflicts 315
Undoing Merges 327
Other Types of Merges 330
Rerere 335
Debugging with Git 341
File Annotation 341
Binary Search 343
Submodules 345
Starting with Submodules 345
Cloning a Project with Submodules 347
Working on a Project with Submodules 349
Submodule Tips 360
Issues with Submodules 362
Bundling 364
Replace 368
Credential Storage 377
Under the Hood 378
A Custom Credential Cache 381
Summary 383
CHAPTER 8: Customizing Git 385
Git Configuration 385
Basic Client Configuration 386
Table of Contents
Colors in Git 389
External Merge and Di Tools 390
Formatting and Whitespace 394
Server Configuration 396
Git Attributes 397
Binary Files 397
Keyword Expansion 400
Exporting Your Repository 403
Merge Strategies 404
Git Hooks 405
Installing a Hook 405
Client-Side Hooks 406
Server-Side Hooks 408
An Example Git-Enforced Policy 409
Server-Side Hook 409
Client-Side Hooks 415
Summary 419
CHAPTER 9: Git and Other Systems 421
Git as a Client 421
Git and Subversion 421
Git and Mercurial 433
Git and Perforce 442
Git and TFS 458
Migrating to Git 467
Subversion 468
Mercurial 470
Perforce 472
TFS 475
A Custom Importer 476
Table of Contents
Summary 483
CHAPTER 10: Git Internals 485
Plumbing and Porcelain 485
Git Objects 486
Tree Objects 489
Commit Objects 492
Object Storage 495
Git References 497
The HEAD 498
Tags 499
Remotes 501
Packfiles 501
The Refspec 505
Pushing Refspecs 507
Deleting References 507
Transfer Protocols 508
The Dumb Protocol 508
The Smart Protocol 510
Protocols Summary 513
Maintenance and Data Recovery 514
Maintenance 514
Data Recovery 515
Removing Objects 518
Environment Variables 522
Global Behavior 522
Repository Locations 522
Pathspecs 523
Committing 523
Networking 524
Diing and Merging 524
Table of Contents
Debugging 525
Miscellaneous 527
Summary 527
Git in Other Environments 529
Embedding Git in your Applications 545
Git Commands 557
Index 575
Table of Contents
Inicio - Sobre el Control de
Este capítulo habla de cómo comenzar a utilizar Git. Empezaremos describien-
do algunos conceptos básicos sobre las herramientas de control de versiones;
después, trataremos sobre cómo hacer que Git funcione en tu sistema; final-
mente, exploraremos cómo configurarlo para empezar a trabajar con él. Al final
de este capítulo deberás entender las razones por las cuales Git existe y con-
viene que lo uses, y deberás tener todo preparado para comenzar.
Acerca del Control de Versiones
¿Qué es control de versiones, y por qué debería importarte? Control de ver-
siones es un sistema que registra los cambios realizados en un archivo o con-
junto de archivos a lo largo del tiempo, de modo que puedas recuperar ver-
siones específicas más adelante. Aunque en los ejemplos de este libro usarás
archivos de código fuente como aquellos cuya versión está siendo controlada,
en realidad puedes hacer lo mismo con casi cualquier tipo de archivo que en-
cuentres en una computadora.
Si eres diseñador gráfico o de web y quieres mantener cada versión de una
imagen o diseño (algo que sin duda vas a querer), usar un sistema de control de
versiones (VCS por sus siglas en inglés) es una muy decisión muy acertada. Di-
cho sistema te permite regresar a versiones anteriores de tus archivos, regresar
a una versión anterior del proyecto completo, comparar cambios a lo largo del
tiempo, ver quién modificó por última vez algo que pueda estar causando prob-
lemas, ver quién introdujo un problema y cuándo, y mucho más. Usar un VCS
también significa generalmente que si arruinas o pierdes archivos, será posible
recuperarlos fácilmente. Adicionalmente, obtendrás todos estos beneficios a
un costo muy bajo.
Local version
Sistemas de Control de Versiones Locales
Un método de control de versiones usado por muchas personas es copiar los
archivos a otro directorio (quizás indicando la fecha y hora en que lo hicieron, si
son ingeniosos). Este método es muy común porque es muy sencillo, pero tam-
bién es tremendamente propenso a errores. Es fácil olvidar en qué directorio te
encuentras, y guardar accidentalmente en el archivo equivocado o sobrescribir
archivos que no querías.
Para afrontar este problema los programadores desarrollaron hace tiempo
VCS locales que contenían una simple base de datos en la que se llevaba el reg-
istro de todos los cambios realizados a los archivos.
Una de las herramientas de control de versiones más popular fue un sistema
llamado RCS, que todavía podemos encontrar en muchas de las computadoras
actuales. Incluso el famoso sistema operativo Mac OS X incluye el comando rcs
cuando instalas las herramientas de desarrollo. Esta herramienta funciona
guardando conjuntos de parches (es decir, las diferencias entre archivos) en un
CHAPTER 1: Inicio - Sobre el Control de Versiones
Centralized version
formato especial en disco, y es capaz de recrear cómo era un archivo en cualqu-
ier momento a partir de dichos parches.
Sistemas de Control de Versiones Centralizados
El siguiente gran problema con el que se encuentran las personas es que neces-
itan colaborar con desarrolladores en otros sistemas. Los sistemas de Control
de Versiones Centralizados (CVCS por sus siglas en inglés) fueron desarrollados
para solucionar este problema. Estos sistemas, como CVS, Subversion, y Per-
force, tienen un único servidor que contiene todos los archivos versionados, y
varios clientes que descargan los archivos desde ese lugar central. Este ha sido
el estándar para el control de versiones por muchos años.
Esta configuración ofrece muchas ventajas, especialmente frente a VCS lo-
cales. Por ejemplo, todas las personas saben hasta cierto punto en qué están
trabajando los otros colaboradores del proyecto. Los administradores tienen
control detallado sobre qué puede hacer cada usuario, y es mucho más fácil ad-
ministrar un CVCS que tener que lidiar con bases de datos locales en cada cli-
Sin embargo, esta configuración también tiene serias desventajas. La más
obvia es el punto único de fallo que representa el servidor centralizado. Si ese
Acerca del Control de Versiones
servidor se cae durante una hora, entonces durante esa hora nadie podrá cola-
borar o guardar cambios en archivos en los que hayan estado trabajando. Si el
disco duro en el que se encuentra la base de datos central se corrompe, y no se
han realizado copias de seguridad adecuadamente, se perderá toda la informa-
ción del proyecto, con excepción de las copias instantáneas que las personas
tengan en sus máquinas locales. Los VCS locales sufren de este mismo prob-
lema: Cuando tienes toda la historia del proyecto en un mismo lugar, te arries-
gas a perderlo todo.
Sistemas de Control de Versiones Distribuidos
Los sistemas de Control de Versiones Distribuidos (DVCS por sus siglas en in-
glés) ofrecen soluciones para los problemas que han sido mencionados. En un
DVCS (como Git, Mercurial, Bazaar o Darcs), los clientes no solo descargan la úl-
tima copia instantánea de los archivos, sino que se replica completamente el
repositorio. De esta manera, si un servidor deja de funcionar y estos sistemas
estaban colaborando a través de él, cualquiera de los repositorios disponibles
en los clientes puede ser copiado al servidor con el fin de restaurarlo. Cada clon
es realmente una copia completa de todos los datos.
CHAPTER 1: Inicio - Sobre el Control de Versiones
Distributed version
Además, muchos de estos sistemas se encargan de manejar numerosos re-
positorios remotos con los cuales pueden trabajar, de tal forma que puedes co-
laborar simultáneamente con diferentes grupos de personas en distintas mane-
ras dentro del mismo proyecto. Esto permite establecer varios flujos de trabajo
que no son posibles en sistemas centralizados, como pueden ser los modelos
Acerca del Control de Versiones
Una breve historia de Git
Como muchas de las grandes cosas en esta vida, Git comenzó con un poco de
destrucción creativa y una gran polémica.
El kernel de Linux es un proyecto de soware de código abierto con un al-
cance bastante amplio. Durante la mayor parte del mantenimiento del kernel
de Linux (1991-2002), los cambios en el soware se realizaban a través de
parches y archivos. En el 2002, el proyecto del kernel de Linux empezó a usar un
DVCS propietario llamado BitKeeper.
En el 2005, la relación entre la comunidad que desarrollaba el kernel de Li-
nux y la compañía que desarrollaba BitKeeper se vino abajo, y la herramienta
dejó de ser ofrecida de manera gratuita. Esto impulsó a la comunidad de desar-
rollo de Linux (y en particular a Linus Torvalds, el creador de Linux) a desarrol-
lar su propia herramienta basada en algunas de las lecciones que aprendieron
mientras usaban BitKeeper. Algunos de los objetivos del nuevo sistema fueron
los siguientes:
Diseño sencillo
Gran soporte para desarrollo no lineal (miles de ramas paralelas)
Completamente distribuido
Capaz de manejar grandes proyectos (como el kernel de Linux) eficiente-
ment (velocidad y tamaño de los datos)
Desde su nacimiento en el 2005, Git ha evolucionado y madurado para ser
fácil de usar y conservar sus características iniciales. Es tremendamente rápido,
muy eficiente con grandes proyectos, y tiene un increíble sistema de ramifica-
ción (branching) para desarrollo no lineal (véase Chapter 3) (véase el Capítulo
Fundamentos de Git
Entonces, ¿qué es Git en pocas palabras? Es muy importante entender bien esta
sección, porque si entiendes lo que es Git y los fundamentos de cómo funciona,
probablemente te será mucho más fácil usar Git efectivamente. A medida que
aprendas Git, intenta olvidar todo lo que posiblemente conoces acerca de otros
VCS como Subversion y Perforce. Hacer esto te ayudará a evitar confusiones su-
tiles a la hora de utilizar la herramienta. Git almacena y maneja la información
de forma muy diferente a esos otros sistemas, a pesar de que su interfaz de
usuario es bastante similar. Comprender esas diferencias evitará que te confun-
das a la hora de usarlo.
CHAPTER 1: Inicio - Sobre el Control de Versiones
Storing data as
changes to a base
version of each le.
Storing data as
snapshots of the
project over time.
Copias instantáneas, no diferencias
La principal diferencia entre Git y cualquier otro VCS (incluyendo Subversion y
sus amigos) es la forma en la que manejan sus datos. Conceptualmente, la
mayoría de los otros sistemas almacenan la información como una lista de
cambios en los archivos. Estos sistemas (CVS, Subversion, Perforce, Bazaar,
etc.) manejan la información que almacenan como un conjunto de archivos y
las modificaciones hechas a cada uno de ellos a través del tiempo.
Git no maneja ni almacena sus datos de esta forma. Git maneja sus datos
como un conjunto de copias instantáneas de un sistema de archivos miniatura.
Cada vez que confirmas un cambio, o guardas el estado de tu proyecto en Git,
él básicamente toma una foto del aspecto de todos tus archivos en ese momen-
to, y guarda una referencia a esa copia instantánea. Para ser eficiente, si los ar-
chivos no se han modificado Git no almacena el archivo de nuevo, sino un en-
lace al archivo anterior idéntico que ya tiene almacenado. Git maneja sus datos
como una secuencia de copias instantáneas.
Fundamentos de Git
Esta es una diferencia importante entre Git y prácticamente todos los demás
VCS. Hace que Git reconsidere casi todos los aspectos del control de versiones
que muchos de los demás sistemas copiaron de la generación anterior. Esto
hace que Git se parezca más a un sistema de archivos miniatura con algunas
herramientas tremendamente poderosas desarrolladas sobre él, que a un VCS.
Exploraremos algunos de los beneficios que obtienes al modelar tus datos de
esta manera cuando veamos ramificación (branching) en Git en el (véase Chap-
ter 3) (véase el Capítulo 3). FIXME
Casi todas las operaciones son locales
La mayoría de las operaciones en Git sólo necesitan archivos y recursos locales
para funcionar. Por lo general no se necesita información de ningún otro orde-
nador de tu red. Si estás acostumbrado a un CVCS donde la mayoría de las op-
eraciones tienen el costo adicional del retardo de la red, este aspecto de Git te
va a hacer pensar que los dioses de la velocidad han bendecido Git con poderes
sobrenaturales. Debido a que tienes toda la historia del proyecto ahí mismo, en
tu disco local, la mayoría de las operaciones parecen prácticamente inmedia-
Por ejemplo, para navegar por la historia del proyecto, Git no necesita con-
ectarse al servidor para obtener la historia y mostrártela - simplemente la lee
directamente de tu base de datos local. Esto significa que ves la historia del
proyecto casi instantáneamente. Si quieres ver los cambios introducidos en un
archivo entre la versión actual y la de hace un mes, Git puede buscar el archivo
hace un mes y hacer un cálculo de diferencias localmente, en lugar de tener
que pedirle a un servidor remoto que lo haga u obtener una versión antigua
desde la red y hacerlo de manera local.
Esto también significa que hay muy poco que no puedes hacer si estás de-
sconectado o sin VPN. Si te subes a un avión o a un tren y quieres trabajar un
poco, puedes confirmar tus cambios felizmente hasta que consigas una conex-
ión de red para subirlos. Si te vas a casa y no consigues que tu cliente VPN fun-
cione correctamente, puedes seguir trabajando. En muchos otros sistemas, es-
to es imposible o muy engorroso. En Perforce, por ejemplo, no puedes hacer
mucho cuando no estás conectado al servidor. En Subversion y CVS, puedes ed-
itar archivos, pero no puedes confirmar los cambios a tu base de datos (porque
tu base de datos no tiene conexión). Esto puede no parecer gran cosa, pero te
sorprendería la diferencia que puede suponer.
CHAPTER 1: Inicio - Sobre el Control de Versiones
Git tiene integridad
Todo en Git es verificado mediante una suma de comprobación (checksum en
inglés) antes de ser almacenado, y es identificado a partir de ese momento me-
diante dicha suma. Esto significa que es imposible cambiar los contenidos de
cualquier archivo o directorio sin que Git lo sepa. Esta funcionalidad está inte-
grada en Git al más bajo nivel y es parte integral de su filosofía. No puedes
perder información durante su transmisión o sufrir corrupción de archivos sin
que Git sea capaz de detectarlo.
El mecanismo que usa Git para generar esta suma de comprobación se con-
oce como hash SHA-1. Se trata de una cadena de 40 caracteres hexadecimales
(0-9 y a-f), y se calcula en base a los contenidos del archivo o estructura del di-
rectorio en Git. Un hash SHA-1 se ve de la siguiente forma:
Verás estos valores hash por todos lados en Git porque son usados con mu-
cha frecuencia. De hecho, Git guarda todo no por nombre de archivo, sino por
el valor hash de sus contenidos.
Git generalmente solo añade información
Cuando realizas acciones en Git, casi todas ellas solo añaden información a la
base de datos de Git. Es muy difícil conseguir que el sistema haga algo que no
se pueda enmendar, o que de algún modo borre información. Como en cualqui-
er VCS, puedes perder o estropear cambios que no has confirmado todavía.
Pero después de confirmar una copia instantánea en Git es muy difícil de per-
derla, especialmente si envías tu base de datos a otro repositorio con regulari-
Esto hace que usar Git sea un placer, porque sabemos que podemos experi-
mentar sin peligro de estropear gravemente las cosas. Para un análisis más ex-
haustivo de cómo almacena Git su información y cómo puedes recuperar datos
aparentemente perdidos, ver “Deshacer Cosas” Capítulo 2. FIXME
Los Tres Estados
Ahora presta atención. Esto es lo más importante qu debes recordar acerca de
Git si quieres que el resto de tu proceso de aprendizaje prosiga sin problemas.
Git tiene tres estados principales en los que se pueden encontrar tus archivos:
confirmado (committed), modificado (modified), y preparado (staged). Confir-
mado significa que los datos están almacenados de manera segura en tu base
de datos local. Modificado significa que has modificado el archivo pero todavía
Fundamentos de Git
Working directory,
staging area, and Git
no lo has confirmado a tu base de datos. Preparado significa que has marcado
un archivo modificado en su versión actual para que vaya en tu próxima confir-
Esto nos lleva a las tres secciones principales de un proyecto de Git: El direc-
torio de Git (Git directory), el directorio de trabajo (working directory), y el área
de preparación (staging area).
El directorio de Git es donde se almacenan los metadatos y la base de datos
de objetos para tu proyecto. Es la parte más importante de Git, y es lo que se
copia cuando clonas un repositorio desde otra computadora.
El directorio de trabajo es una copia de una versión del proyecto. Estos ar-
chivos se sacan de la base de datos comprimida en el directorio de Git, y se co-
locan en disco para que los puedas usar o modificar.
El área de preparación es un archivo, generalmente contenido en tu director-
io de Git, que almacena información acerca de lo que va a ir en tu próxima con-
firmación. A veces se le denomina índice (“index”), pero se está convirtiendo en
estándar el referirse a ella como el área de preparación.
El flujo de trabajo básico en Git es algo así:
1. Modificas una serie de archivos en tu directorio de trabajo.
2. Preparas los archivos, añadiéndolos a tu área de preparación.
3. Confirmas los cambios, lo que toma los archivos tal y como están en el
área de preparación y almacena esa copia instantánea de manera perma-
nente en tu directorio de Git.
CHAPTER 1: Inicio - Sobre el Control de Versiones
Si una versión concreta de un archivo está en el directorio de Git, se consid-
era confirmada (committed). Si ha sufrido cambios desde que se obtuvo del re-
positorio, pero ha sido añadida al área de preparación, está preparada (staged).
Y si ha sufrido cambios desde que se obtuvo del repositorio, pero no se ha pre-
parado, está modificada (modified). En el Chapter 2 Capítulo 2 aprenderás
más acerca de estos estados y de cómo puedes aprovecharlos o saltarte toda la
parte de preparación.
La Línea de Comandos
Existen muchas formas de usar Git. Por un lado tenemos las herramientas origi-
nales de línea de comandos, y por otro lado tenemos una gran variedad de in-
terfaces de usuario con distintas capacidades. En ese libro vamos a utilizar Git
desde la línea de comandos. La línea de comandos en el único lugar en donde
puedes ejecutar todos los comandos de Git - la mayoría de interfaces gráficas
de usuario solo implementan una parte de las características de Git por moti-
vos de simplicidad. Si tú sabes cómo realizar algo desde la línea de comandos,
seguramente serás capaz de averiguar cómo hacer lo mismo desde una interfaz
gráfica. Sin embargo, la relación opuesta no es necesariamente cierta. Así mis-
mo, la decisión de qué cliente gráfico utilizar depende totalmente de tu gusto,
pero todos los usuarios tendrán las herramientas de línea de comandos instala-
das y disponibles.
Nosotros esperamos que sepas cómo abrir el Terminal en Mac, o el “Com-
mand Prompt” o “Powershell” en Windows. Si no entiendes de lo que estamos
hablando aquí, te recomendamos que hagas una pausa para investigar acerca
de esto de tal forma que puedas entender el resto de las explicaciones y de-
scripciones que siguen en este libro.
Instalación de Git
Antes de empezar a utilizar Git, tienes que instalarlo en tu computadora. Inclu-
so si ya está instalado, este es posiblemente un buen momento para actualizar-
lo a su última versión. Puedes instalarlo como un paquete, a partir de un archi-
vo instalador, o bajando el código fuente y compilándolo tú mismo.
Este libro fue escrito utilizando la versión 2.0.0 de Git. Aun cuando la
mayoría de comandos que usaremos deben funcionar en versiones más
antiguas de Git, es posible que algunos de ellos no funcionen o funcionen
ligeramente diferente si estás utilizando una versión anterior de Git. De-
bido a que Git es particularmente bueno en preservar compatibilidad ha-
cia atrás, cualquier versión posterior a 2.0 debe funcionar bien.
La Línea de Comandos
Instalación en Linux
Si quieres instalar Git en Linux a través de un instalador binario, en general
puedes hacerlo mediante la herramienta básica de administración de paquetes
que trae tu distribución. Si estás en Fedora por ejemplo, puedes usar yum:
$ yum install git
Si estás en una distribución basada en Debian como Ubuntu, puedes usar
If you’re on a Debian-based distribution like Ubuntu, try apt-get:
$ apt-get install git
Para opciones adicionales, la página web de Git tiene instrucciones para la
instalación en diferentes tipos de Unix. Puedes encontrar esta información en
Instalación en Mac
Hay varias maneras de instalar Git en un Mac. Probablemente la más sencilla es
instalando las herramientas Xcode de Línea de Comandos. En Mavericks (10.9)
o superior puedes hacer esto desde el Terminal si intentas ejecutar git por pri-
mera vez. Si no lo tienes instalado, te preguntará si deseas instalarlo.
Si deseas una versión más actualizada, puedes hacerlo partir de un instala-
dor binario. Un instalador de Git para OSX es mantenido en la página web de
Git. Lo puedes descargar en
CHAPTER 1: Inicio - Sobre el Control de Versiones
Git OS X Installer.
También puedes instalarlo como parte del instalador de Github para Mac. Su
interfaz gráfica de usuario tiene la opción de instalar las herramientas de línea
de comandos. Puedes descargar esa herramienta desde el sitio web de Github
para Mar en
Instalación en Windows
También hay varias maneras de instalar Git en Windows. La forma más oficial
está disponible para ser descargada en el sitio web de Git. Solo tienes que visi-
tar y la descarga empezará automática-
mente. Fíjate que éste es un proyecto conocido como Git para Windows (tam-
bién llamado msysGit), el cual es diferente de Git. Para más información acerca
de este proyecto visita
Otra forma de obtener Git fácilmente es mediante la instalación de GitHub
para Windows. El instalador incluye la versión de línea de comandos y la inter-
faz de usuario de Git. Además funciona bien con Powershell y establece correc-
tamente “caching” de credenciales y configuración CRLF adecuada. Aprendere-
mos acerca de todas estas cosas un poco más adelante, pero por ahora es sufi-
ciente mencionar que éstas son cosas que deseas. Puedes descargar este insta-
lador del sitio web de GitHub para Windows en
Instalación de Git
Instalación a partir del Código Fuente
Algunas personas desean instalar Git a partir de su código fuente debido a que
obtendrás una versión más reciente. Los instaladores binarios tienen a estar un
poco atrasados. Sin embargo, esto ha hecho muy poca diferencia a medida que
Git ha madurado en los últimos años.
Para instalar Git desde el código fuente necesitas tener las siguientes libre-
rías de las que Git depende: curl, zlib, openssl, expat y libiconv. Por ejemplo, si
estás en un sistema que tiene yum (como Fedora) o apt-get (como un sistema
basado en Debian), puedes usar estos comandos para instalar todas las de-
$ yum install curl-devel expat-devel gettext-devel \
openssl-devel zlib-devel
$ apt-get install libcurl4-gnutls-dev libexpat1-dev gettext \
libz-dev libssl-dev
Cuando tengas todas las dependencias necesarias, puedes descargar la ver-
sión más reciente de Git en diferentes sitios. Puedes obtenerlo a partir del sitio enware/scm/git, o su “mirror” en
el sitio web de GitHub en Generalmente la
más reciente versión en la página web de GitHub es un poco mejor, pero la pág-
ina de también tiene ediciones con firma en caso de que desees veri-
ficar tu descarga.
Luego tienes que compilar e instalar de la siguiente manera:
$ tar -zxf git-2.0.0.tar.gz
$ cd git-2.0.0
$ make configure
$ ./configure --prefix=/usr
$ make all doc info
$ sudo make install install-doc install-html install-info
Una vez hecho esto, también puedes obtener Git, a través del propio Git,
para futuras actualizaciones:
$ git clone git://
Configurando Git por primera vez
Ahora que tienes Git en tu sistema, vas a querer hacer algunas cosas para per-
sonalizar tu entorno de Git. Es necesario hacer estas cosas solamente una vez
en tu computadora, y se mantendrán entre actualizaciones. También puedes
CHAPTER 1: Inicio - Sobre el Control de Versiones
cambiarlas en cualquier momento volviendo a ejecutar los comandos corre-
Git trae una herramienta llamada git config que te permite obtener y es-
tablecer variables de configuración que controlan el aspecto y funcionamiento
de Git. Estas variables pueden almacenarse en tres sitios distintos:
1. Archivo /etc/gitconfig: Contiene valores para todos los usuarios del
sistema y todos sus repositorios. Si pasas la opción --system a git
config, lee y escribe específicamente en este archivo.
2. Archivo ~/.gitconfig o ~/.config/git/config: Este archivo es espe-
cífico a tu usuario. Puedes hacer que Git lea y escriba específicamente en
este archivo pasando la opción --global.
3. Archivo config en el directorio de Git (es decir, .git/config) del reposi-
torio que estés utilizando actualmente: Este archivo es específico al repo-
sitorio actual.
Cada nivel sobrescribe los valores del nivel anterior, por lo que los valores
de .git/config tienen preferencia sobre los de /etc/gitconfig.
En sistemas Windows, Git busca el archivo .gitconfig en el directorio
$HOME (para mucha gente será (C:\Users\$USER). También busca el archi-
vo /etc/gitconfig, aunque esta ruta es relativa a la raíz MSys, que es donde
decidiste instalar Git en tu sistema Windows cuando ejecutaste el instalador.
Tu Identidad
Lo primero que deberás hacer cuando instales Git es establecer tu nombre de
usuario y dirección de correo electrónico. Esto es importante porque los “com-
mits” de Git usan esta información, y es introducida de manera inmutable en
los commits que envías:
$ git config --global "John Doe"
$ git config --global
De nuevo, solo necesitas hacer esto una vez si especificas la opción --
global, ya que Git siempre usará esta información para todo lo que hagas en
ese sistema. Si quieres sobrescribir esta información con otro nombre o direc-
ción de correo para proyectos específicos, puedes ejecutar el comando sin la
opción --global cuando estés en ese proyecto.
Muchas de las herramientas de interfaz gráfica te ayudarán a hacer esto la
primera vez que las uses.
Configurando Git por primera vez
Tu Editor
Ahora que tu identidad está configurada, puedes elegir el editor de texto por
defecto que se utilizará cuando Git necesite que introduzcas un mensaje. Si no
indicas nada, Git usa el editor por defecto de tu sistema, que generalmente es
Vim. Si quieres usar otro editor de texto como Emacs, puedes hacer lo si-
$ git config --global core.editor emacs
Vim y Emacs son editores de texto frecuentemente usados por desarrolla-
dores en sistemas basados en Unix como Linux y Mac. Si no estás familiarizado
con ninguno de estos editores o estás en un sistema Windows, es posible que
necesites buscar instrucciones acerca de cómo configurar tu editor favorito con
Git. Si no configuras un editor así y no conoces acerca de Vim o Emacs, es muy
factible que termines en un estado bastante confuso en el momento en que
sean ejecutados.
Comprobando tu Configuración
Si quieres comprobar tu configuración, puedes usar el comando git config
--list para mostrar todas las propiedades que Git ha configurado:
$ git config --list Doe
Puede que veas claves repetidas, porque Git lee la misma clave de distintos
archivos (/etc/gitconfig y ~/.gitconfig, por ejemplo). En ese caso, Git
usa el último valor para cada clave única que ve.
También puedes comprobar qué valor que Git utilizará para una clave espe-
cífica ejecutando git config <key>:
CHAPTER 1: Inicio - Sobre el Control de Versiones
$ git config
John Doe
¿Cómo obtener ayuda?
Si alguna vez necesitas ayuda usando Git, existen tres formas de ver la página
del manual (manpage) para cualquier comando de Git:
$ git help <verb>
$ git <verb> --help
$ man git-<verb>
Por ejemplo, puedes ver la página del manual para el comando config ejecu-
$ git help config
Estos comandos son muy útiles porque puedes acceder a ellos desde cual-
quier sitio, incluso sin conexión. Si las páginas del manual y este libro no son
suficientes y necesitas que te ayude una persona, puedes probar en los canales
#git o #github del servidor de IRC Freenode ( Estos canales es-
tán llenos de cientos de personas que conocen muy bien Git y suelen estar dis-
puestos a ayudar.
Para este momento debes tener una comprensión básica de lo que es Git, y de
cómo se diferencia de cualquier otro sistema de control de versiones centraliza-
do que pudieras haber utilizado previamente. De igual manera, Git debe estar
funcionando en tu sistema y configurado con tu identidad personal. Es hora de
aprender los fundamentos de Git.
¿Cómo obtener ayuda?
Fundamentos de Git
Si pudieras leer solo un capítulo para empezar a trabajar con Git, este es el ca-
pítulo que debes leer. Este capítulo cubre todos los comandos básicos que nec-
esitas para hacer la gran mayoría de cosas a las que eventualmente vas a dedi-
car tu tiempo mientras trabajas con Git. Al final del capítulo, deberás ser capaz
de configurar e inicializar un repositorio, comenzar y detener el seguimiento de
archivos, y preparar (stage) y confirmar (commit) cambios. También te enseñar-
emos a configurar Git para que ignore ciertos archivos y patrones, cómo en-
mendar errores rápida y fácilmente, cómo navegar por la historia de tu proyec-
to y ver cambios entre confirmaciones, y cómo enviar (push) y recibir (pull) de
repositorios remotos.
Obteniendo un repositorio Git
Puedes obtener un proyecto Git de dos maneras. La primera es tomar un
proyecto o directorio existente e importarlo en Git. La segunda es clonar un re-
positorio existente en Git desde otro servidor.
Inicializando un repositorio en un directorio existente
Si estás empezando a seguir un proyecto existente en Git, debes ir al directorio
del proyecto y usar el siguiente comando:
$ git init
Esto crea un subdirectorio nuevo llamado .git, el cual contiene todos los
archivos necesarios del repositorio – un esqueleto de un repositorio de Git. To-
davía no hay nada en tu proyecto que esté bajo seguimiento. Puedes revisar
Chapter 10 para obtener más información acerca de los archivos presentes en
el directorio .git que acaba de ser creado.
Si deseas empezar a controlar versiones de archivos existentes (a diferencia
de un directorio vacío), probablemente deberías comenzar el seguimiento de
esos archivos y hacer una confirmación inicial. Puedes conseguirlo con unos
pocos comandos git add para especificar qué archivos quieres controlar, se-
guidos de un git commit para confirmar los cambios:
$ git add *.c
$ git add LICENSE
$ git commit -m 'initial project version'
Veremos lo que hacen estos comandos más adelante. En este momento,
tienes un repositorio de Git con archivos bajo seguimiento y una confirmación
Clonando un repositorio existente
Si deseas obtener una copia de un repositorio Git existente — por ejemplo, un
proyecto en el que te gustaría contribuir — el comando que necesitas es git
clone. Si estás familizarizado con otros sistemas de control de versiones como
Subversion, verás que el comando es “clone” en vez de “checkout”. Es una dis-
tinción importante, ya que Git recibe una copia de casi todos los datos que
tiene el servidor. Cada versión de cada archivo de la historia del proyecto es
descargada por defecto cuando ejecutas git clone. De hecho, si el disco de tu
servidor se corrompe, puedes usar cualquiera de los clones en cualquiera de
los clientes para devolver al servidor al estado en el que estaba cuando fue clo-
nado (puede que pierdas algunos hooks del lado del servidor y demás, pero to-
da la información acerca de las versiones estará ahí) — véase “Configurando
Git en un servidor” para más detalles.
Puedes clonar un repositorio con git clone [url]. Por ejemplo, si
quieres clonar la librería de Git llamada libgit2 puedes hacer algo así:
$ git clone
Esto crea un directorio llamado libgit2, inicializa un directorio .git en su
interior, descarga toda la información de ese repositorio y saca una copia de
trabajo de la última versión. Si te metes en el directorio libgit2, verás que es-
tán los archivos del proyecto listos para ser utilizados. Si quieres clonar el repo-
sitorio a un directorio con otro nombre que no sea libgit2, puedes especifi-
carlo con la siguiente opción de línea de comandos:
CHAPTER 2: Fundamentos de Git
$ git clone mylibgit
Ese comando hace lo mismo que el anterior, pero el directorio de destino se
llamará mylibgit.
Git te permite usar distintos protocolos de transferencia. El ejemplo anterior
usa el protocolo https://, pero también puedes utilizar git:// o usuar-
io@servidor:ruta/del/repositorio.git que utiliza el protocolo de trans-
ferencia SSH. En “Configurando Git en un servidor” se explicarán todas las
opciones disponibles a la hora de configurar el acceso a tu repositorio de Git, y
las ventajas e inconvenientes de cada una.
Guardando cambios en el Repositorio
Ya tienes un repositorio Git y un checkout o copia de trabajo de los archivos de
dicho proyecto. El siguiente paso es realizar algunos cambios y confirmar in-
stantáneas de esos cambios en el repositorio cada vez que el proyecto alcance
un estado que quieras conservar.
Recuerda que cada archivo de tu repositorio puede tener dos estados: ras-
treados y sin rastrear. Los archivos rastreados (tracked files en inglés) son todos
aquellos archivos que estaban en la última instantánea del proyecto; pueden
ser archivos sin modificar, modificados o preparados. Los archivos sin rastrear
son todos los demás - cualquier otro archivo en tu directorio de trabajo que no
estaba en tu última instantánea y que no están en el área de preparación (stag-
ing area). Cuando clonas por primera vez un repositorio, todos tus archivos es-
tarán rastreados y sin modificar pues acabas de sacarlos y aun no han sido edi-
Mientras editas archivos, Git los ve como modificados, pues han sido cam-
biados desde su último commit. Luego preparas estos archivos modificados y
finalmente confirmas todos los cambios preparados, y repites el ciclo.
Guardando cambios en el Repositorio
El ciclo de vida del
estado de tus
Revisando el Estado de tus Archivos
La herramienta principal para determinar qué archivos están en qué estado es
el comando git status. Si ejecutas este comando inmediatamente después
de clonar un repositorio, deberías ver algo como esto:
$ git status
On branch master
nothing to commit, working directory clean
Esto significa que tienes un directorio de trabajo limpio - en otras palabras,
que no hay archivos rastreados y modificados. Además, Git no encuentra nin-
gún archivo sin rastrear, de lo contrario aparecerían listados aquí. Finalmente,
el comando te indica en cuál rama estás y te informa que no ha variado con
respecto a la misma rama en el servidor. Por ahora, la rama siempre será “mas-
ter”, que es la rama por defecto; no le prestaremos atención ahora. Chapter 3
tratará en detalle las ramas y las referencias.
Supongamos que añades un nuevo archivo a tu proyecto, un simple RE-
ADME. Si el archivo no existía antes, y ejecutas git status, verás el archivo sin
rastrear de la siguiente manera:
$ echo 'My Project' > README
$ git status
On branch master
Untracked files:
(use "git add <file>..." to include in what will be committed)
CHAPTER 2: Fundamentos de Git
nothing added to commit but untracked files present (use "git add" to track)
Puedes ver que el archivo README está sin rastrear porque aparece debajo
del encabezado “Untracked files” (“Archivos no rastreados” en inglés) en la sali-
da. Sin rastrear significa que Git ve archivos que no tenías en el commit anterior.
Git no los incluirá en tu próximo commit a menos que se lo indiques explícita-
mente. Se comporta así para evitar incluir accidentalmente archivos binarios o
cualquier otro archivo que no quieras incluir. Como tú sí quieres incluir RE-
ADME, debes comenzar a rastrearlo.
Rastrear Archivos Nuevos
Para comenzar a rastrear un archivo debes usar el comando git add. Para co-
menzar a rastrear el archivo README, puedes ejecutar lo siguiente:
$ git add README
Ahora si vuelves a ver el estado del proyecto, verás que el archivo README
está siendo rastreado y está preparado para ser confirmado:
$ git status
On branch master
Changes to be committed:
(use "git reset HEAD <file>..." to unstage)
new file: README
Puedes ver que está siendo rastreado porque aparece luego del encabezado
“Changes to be committed” (“Cambios a ser confirmados” en inglés). Si confir-
mas en este punto, se guardará en el historial la versión del archivo correspon-
diente al instante en que ejecutaste git add. Anteriormente cuando ejecu-
taste git init, ejecutaste luego git add (files) - lo cual inició el rastreo
de archivos en tu directorio. El comando git add puede recibir tanto una ruta
de archivo como de un directorio; si es de un directorio, el comando añade re-
cursivamente los archivos que están dentro de él.
Guardando cambios en el Repositorio
Preparar Archivos Modificados
Vamos a cambiar un archivo que esté rastreado. Si cambias el archivo rastreado
llamado “” y luego ejecutas el comando git status, verás
algo parecido a esto:
$ git status
On branch master
Changes to be committed:
(use "git reset HEAD <file>..." to unstage)
new file: README
Changes not staged for commit:
(use "git add <file>..." to update what will be committed)
(use "git checkout -- <file>..." to discard changes in working directory)
El archivo “” aparece en una sección llamada “Changes
not staged for commit” (“Cambios no preparado para confirmar” en inglés) - lo
que significa que existe un archivo rastreado que ha sido modificado en el di-
rectorio de trabajo pero que aun no está preparado. Para prepararlo, ejecutas el
comando git add. git add es un comando que cumple varios propósitos - lo
usas para empezar a rastrear archivos nuevos, preparar archivos, y hacer otras
cosas como marcar como resuelto archivos en conflicto por combinación. Es
más útil que lo veas como un comando para “añadir este contenido a la próxi-
ma confirmación” mas que para “añadir este archivo al proyecto. Ejecutemos
git add para preparar el archivo “” y luego ejecutemos
git status:
$ git add
$ git status
On branch master
Changes to be committed:
(use "git reset HEAD <file>..." to unstage)
new file: README
Ambos archivos están preparados y formarán parte de tu próxima confirma-
ción. En este momento, supongamos que recuerdas que debes hacer un peque-
ño cambio en antes de confirmarlo. Abres de nuevo el archi-
CHAPTER 2: Fundamentos de Git
vo, lo cambias y ahora estás listos para confirmar. Sin embargo, ejecutemos
git status una vez más:
$ vim
$ git status
On branch master
Changes to be committed:
(use "git reset HEAD <file>..." to unstage)
new file: README
Changes not staged for commit:
(use "git add <file>..." to update what will be committed)
(use "git checkout -- <file>..." to discard changes in working directory)
¡¿Pero qué…?! Ahora aparece como preparado y como
no preparado. ¿Cómo es posible? Resulta que Git prepara un archivo de acuer-
do al estado que tenía cuando ejecutas el comando git add. Si confirmas
ahora, se confirmará la versión de que tenías la última vez
que ejecutaste git add y no la versión que ves ahora en tu directorio de traba-
jo al ejecutar git commit. Si modificas un archivo luego de ejecutar git add,
deberás ejecutar git add de nuevo para preparar la última versión del archivo:
$ git add
$ git status
On branch master
Changes to be committed:
(use "git reset HEAD <file>..." to unstage)
new file: README
Estatus Abreviado
Si bien es cierto que la salida de git status es bastante explícita, también es
verdad que es muy extensa. Git ofrece una opción para obtener un estatus
abreviado, de manera que puedas ver tus cambios de una forma más compac-
ta. Si ejecutas git status -s o git status --short obtendrás una salida
mucho más simplificada.
Guardando cambios en el Repositorio
$ git status -s
MM Rakefile
A lib/git.rb
M lib/simplegit.rb
?? LICENSE.txt
Los archivos nuevos que no están rastreados tienen un ?? a su lado, los ar-
chivos que están preparados tienen una A y los modificados una M. El estado
aparece en dos columnas - la columna de la izquierda indica el estado prepara-
do y la columna de la derecha indica el estado sin preparar. Por ejemplo, en esa
salida, el archivo README está modificado en el directorio de trabajo pero no
está preparado, mientras que lib/simplegit.rb está modificado y prepara-
do. El archivo Rakefile fue modificado, preparado y modificado otra vez por
lo que existen cambios preparados y sin preparar.
Ignorar Archivos
A veces, tendrás algún tipo de archivo que no quieres que Git añada automáti-
camente o más aun, que ni siquiera quieras que aparezca como no rastreado.
Este suele ser el caso de archivos generados automáticamente como trazas o
archivos creados por tu sistema de construcción. En estos casos, puedes crear
un archivo llamado .gitignore que liste patrones a considerar. Este es un
ejemplo de un archivo .gitignore:
$ cat .gitignore
La primera línea le indica a Git que ignore cualquier archivo que termine en
.o” o “.a” - archivos de objeto o librerías que pueden ser producto de compilar
tu código. La segunda línea le indica a Git que ignore todos los archivos que ter-
mine con una tilde (~), lo cual es usado por varios editores de texto como
Emacs para marcar archivos temporales. También puedes incluir cosas como
trazas, temporales, o pid directamente; documentación generada automática-
mente; etc. Crear un archivo .gitignore antes de comenzar a trabajar es gen-
eralmente una buena idea pues así evitas confirmar accidentalmente archivos
que en realidad no quieres incluir en tu repositorio Git.
Las reglas sobre los patrones que puedes incluir en el archivo .gitignore
son las siguientes:
CHAPTER 2: Fundamentos de Git
Ignorar las líneas en blanco y aquellas que comiencen con #.
Aceptar patrones glob estándar.
Los patrones pueden terminar en barra (/) para especificar un directorio.
Los patrones pueden negarse si se añade al principio el signo de exclama-
ción (!).
Los patrones glob son una especia de expresión regular simplificada usada
por los terminales. Un asterisco (*) corresponde a cero o más caracteres; [abc]
corresponde a cualquier carácter dentro de los corchetes (en este caso a, b o c);
el signo de interrogación (?) corresponde a un carácter cualquier; y los corch-
etes sobre caracteres separados por un guión ([0-9]) corresponde a cualquier
carácter entre ellos (en este caso del 0 al 9). También puedes usar dos asteris-
cos para indicar directorios anidados; a/**/z coincide con a/z, a/b/z,
a/b/c/z, etc.
Aquí puedes ver otro ejemplo de un archivo .gitignore:
# no .a files
# but do track lib.a, even though you're ignoring .a files above
# only ignore the root TODO file, not subdir/TODO
# ignore all files in the build/ directory
# ignore doc/notes.txt, but not doc/server/arch.txt
# ignore all .txt files in the doc/ directory
GitHub mantiene una extensa lista de archivos .gitignore adecuados a
docenas de proyectos y lenguajes en en
caso de que quieras tener un punto de partida para tu proyecto.
Ver los Cambios Preparados y No Preparados
Si el comando git status es muy impreciso para ti - quieres ver exactamente
que ha cambiado, no solo cuáles archivos lo han hecho - puedes usar el coman-
do git diff. Hablaremos sobre git diff más adelante, pero lo usarás pro-
Guardando cambios en el Repositorio
bablemente para responder estas dos preguntas: ¿Qué has cambiado pero aun
no has preparado? y ¿Qué has preparado y está listo para confirmar? A pesar de
que git status responde a estas preguntas de forma muy general listando el
nombre de los archivos, git diff te muestra las líneas exactas que fueron
añadidas y eliminadas, es decir, el parche.
Supongamos que editas y preparas el archivo README de nuevo y luego edi-
tas pero no lo preparas. Si ejecutas el comando git sta-
tus, verás algo como esto:
$ git status
On branch master
Changes to be committed:
(use "git reset HEAD <file>..." to unstage)
new file: README
Changes not staged for commit:
(use "git add <file>..." to update what will be committed)
(use "git checkout -- <file>..." to discard changes in working directory)
Para ver qué has cambiado pero aun no has preparado, escribe git diff
sin más parámetros:
$ git diff
diff --git a/ b/
index 8ebb991..643e24f 100644
--- a/
+++ b/
@@ -65,7 +65,8 @@ branch directly, things can get messy.
Please include a nice description of your changes when you submit your PR;
if we have to read the whole diff to figure out why you're contributing
in the first place, you're less likely to get feedback and have your change
-merged in.
+merged in. Also, split your changes into comprehensive chunks if you patch is
+longer than a dozen lines.
If you are starting to work on a particular area, feel free to submit a PR
that highlights your work in progress (and note in the PR title that it's
Este comando compara lo que tienes en tu directorio de trabajo con lo que
está en el área de preparación. El resultado te indica los cambios que has hecho
pero que aun no has preparado.
CHAPTER 2: Fundamentos de Git
Si quieres ver lo que has preparado y será incluido en la próxima confirma-
ción, puedes usar git diff --staged. Este comando compara tus cambios
preparados con la última instantánea confirmada.
$ git diff --staged
diff --git a/README b/README
new file mode 100644
index 0000000..03902a1
--- /dev/null
+++ b/README
@@ -0,0 +1 @@
+My Project
Es importante resaltar que al llamar a git diff sin parámetros no verás los
cambios desde tu última confirmación - solo verás los cambios que aun no es-
tán preparados. Esto puede ser confuso porque si preparas todos tus cambios,
git diff no te devolverá ninguna salida.
Pasemos a otro ejemplo, si preparas el archivo y luego lo
editas, puedes usar git diff para ver los cambios en el archivo que están pre-
parados y los cambios que no lo están. Si nuestro ambiente es como este:
$ git add
$ echo 'test line' >>
$ git status
On branch master
Changes to be committed:
(use "git reset HEAD <file>..." to unstage)
Changes not staged for commit:
(use "git add <file>..." to update what will be committed)
(use "git checkout -- <file>..." to discard changes in working directory)
Puedes usar git diff para ver qué está sin preparar
$ git diff
diff --git a/ b/
index 643e24f..87f08c8 100644
--- a/
+++ b/
Guardando cambios en el Repositorio
@@ -119,3 +119,4 @@ at the
## Starter Projects
See our [projects list](
+# test line
y git diff --cached para ver que has preparado hasta ahora (--staged y
--cached son sinónimos):
$ git diff --cached
diff --git a/ b/
index 8ebb991..643e24f 100644
--- a/
+++ b/
@@ -65,7 +65,8 @@ branch directly, things can get messy.
Please include a nice description of your changes when you submit your PR;
if we have to read the whole diff to figure out why you're contributing
in the first place, you're less likely to get feedback and have your change
-merged in.
+merged in. Also, split your changes into comprehensive chunks if you patch is
+longer than a dozen lines.
If you are starting to work on a particular area, feel free to submit a PR
that highlights your work in progress (and note in the PR title that it's
A lo largo del libro, continuaremos usando el comando git diff de dis-
tintas maneras. Existe otra forma de ver estas diferencias si prefieres
utilizar una interfaz gráfica u otro programa externo. Si ejecutas git
difftool en vez de git diff, podrás ver los cambios con programas de
este tipo como Araxis, emerge, vimdiff y más. Ejecuta git difftool --
tool-help para ver qué tienes disponible en tu sistema.
Confirmar tus Cambios
Ahora que tu área de preparación está como quieres, puedes confirmar tus
cambios. Recuerda que cualquier cosa que no esté preparada - cualquier archi-
vo que hayas creado o modificado y que no hayas agregado con git add desde
su edición - no será confirmado. Se mantendrán como archivos modificados en
tu disco. En este caso, digamos que la última vez que ejecutaste git status
verificaste que todo estaba preparado y que estás listos para confirmar tus
cambios. La forma más sencilla de confirmar es escribiendo git commit:
CHAPTER 2: Fundamentos de Git
$ git commit
Al hacerlo, arrancará el editor de tu preferencia. (El editor se establece a
través de la variable de ambiente $EDITOR de tu terminal - usualmente es vim o
emacs, aunque puedes configurarlo con el editor que quieras usando el coman-
do git config --global core.editor tal como viste en Chapter 1).
El editor mostrará el siguiente texto (este ejemplo corresponde a una pantal-
la de Vim):
# Please enter the commit message for your changes. Lines starting
# with '#' will be ignored, and an empty message aborts the commit.
# On branch master
# Changes to be committed:
# new file: README
# modified:
".git/COMMIT_EDITMSG" 9L, 283C
Puedes ver que el mensaje de confirmación por defecto contiene la última
salida del comando git status comentada y una línea vacía encima de ella.
Puedes eliminar estos comentarios y escribir tu mensaje de confirmación, o
puedes dejarlos allí para ayudarte a recordar qué estás confirmando. (Para ob-
tener una forma más explícita de recordar qué has modificado, puedes pasar la
opción -v a git commit. Al hacerlo se incluirá en el editor el di de tus cam-
bios para que veas exactamente qué cambios estás confirmando.) Cuando
sales del editor, Git crea tu confirmación con tu mensaje (eliminando el texto
comentado y el di).
Otra alternativa es escribir el mensaje de confirmación directamente en el
comando commit utilizando la opción -m:
$ git commit -m "Story 182: Fix benchmarks for speed"
[master 463dc4f] Story 182: Fix benchmarks for speed
2 files changed, 2 insertions(+)
create mode 100644 README
¡Has creado tu primera confirmación (o commit)! Puedes ver que la confir-
mación te devuelve una salida descriptiva: indica cuál rama as confirmado
(master), que checksum SHA-1 tiene el commit (463dc4f), cuántos archivos
Guardando cambios en el Repositorio
han cambiado y estadísticas sobre las líneas añadidas y eliminadas en el com-
Recuerda que la confirmación guarda una instantánea de tu área de prepar-
ación. Todo lo que no hayas preparado sigue allí modificado; puedes hacer una
nueva confirmación para añadirlo a tu historial. Cada vez que realizas un com-
mit, guardas una instantánea de tu proyecto la cual puedes usar para comparar
o volver a ella luego.
Saltar el Área de Preparación
A pesar de que puede resultar muy útil para ajustar los commits tal como
quieres, el área de preparación es a veces un paso más complejo a lo que nec-
esitas para tu flujo de trabajo. Si quieres saltarte el área de preparación, Git te
ofrece un atajo sencillo. Añadiendo la opción -a al comando git commit harás
que Git prepare automáticamente todos los archivos rastreados antes de con-
firmarlos, ahorrándote el paso de git add:
$ git status
On branch master
Changes not staged for commit:
(use "git add <file>..." to update what will be committed)
(use "git checkout -- <file>..." to discard changes in working directory)
no changes added to commit (use "git add" and/or "git commit -a")
$ git commit -a -m 'added new benchmarks'
[master 83e38c7] added new benchmarks
1 file changed, 5 insertions(+), 0 deletions(-)
Fíjate que en este caso no fue necesario ejecutar git add sobre el archivo antes de confirmar.
Eliminar Archivos
Para eliminar archivos de Git, debes eliminarlos de tus archivos rastreados (o
mejor dicho, eliminarlos del área de preparación) y luego confirmar. Para ello
existe el comando git rm, que además elimina el archivo de tu directorio de
trabajo de manera que no aparezca la próxima vez como un archivo no rastrea-
CHAPTER 2: Fundamentos de Git
Si simplemente eliminas el archivo de tu directorio de trabajo, aparecerá en
la sección “Changes not staged for commit” (esto es, sin preparar) en la salida
de git status:
$ rm
$ git status
On branch master
Your branch is up-to-date with 'origin/master'.
Changes not staged for commit:
(use "git add/rm <file>..." to update what will be committed)
(use "git checkout -- <file>..." to discard changes in working directory)
no changes added to commit (use "git add" and/or "git commit -a")
Ahora, si ejecutas git rm, entonces se prepara la eliminación del archivo:
$ git rm
rm ''
$ git status
On branch master
Changes to be committed:
(use "git reset HEAD <file>..." to unstage)
Con la próxima confirmación, el archivo habrá desaparecido y no volverá a
ser rastreado. Si modificaste el archivo y ya lo habías añadido al índice, tendrás
que forzar su eliminación con la opción -f. Esta propiedad existe por seguri-
dad, para prevenir que elimines accidentalmente datos que aun no han sido
guardados como una instantánea y que por lo tanto no podrás recuperar luego
con Git.
Otra cosa que puedas querer hacer es mantener el archivo en tu directorio
de trabajo pero eliminarlo del área de preparación. En otras palabras, quisieras
mantener el archivo en tu disco duro pero sin que Git lo siga rastreando. Esto
puede ser particularmente útil si olvidaste añadir algo en tu archivo .gi-
tignore y lo preparaste accidentalmente, algo como un gran archivo de trazas
a un montón de archivos compilados .a. Para hacerlo, utiliza la opción --
$ git rm --cached README
Guardando cambios en el Repositorio
Al comando git rm puedes pasarle archivos, directorios y patrones glob. Lo
que significa que puedes hacer cosas como
$ git rm log/\*.log
Fíjate en la barra invertida (\) antes del asterisco *. Esto es necesario porque
Git hace su propia expansión de nombres de archivo, aparte de la expansión
hecha por tu terminal. Este comando elimina todos los archivo que tengan la
extensión .log dentro del directorio log/. O también puedes hacer algo como:
$ git rm \*~
Este comando elimina todos los archivos que acaben con ~.
Cambiar el Nombre de los Archivos
Al contrario que muchos sistemas VCS, Git no rastrea explícitamente los cam-
bios de nombre en archivos. Si renombras un archivo en Git, no se guardará
ningún metadato que indique que renombraste el archivo. Sin embargo, Git es
bastante listo como para detectar estos cambios luego que los has hecho - más
adelante, veremos cómo se detecta el cambio de nombre.
Por esto, resulta confuso que Git tenga un comando mv. Si quieres renom-
brar un archivo en Git, puedes ejecutar algo como
$ git mv file_from file_to
y funcionará bien. De hecho, si ejecutas algo como eso y ves el estatus, verás
que Git lo considera como un renombramiento de archivo:
$ git mv README
$ git status
On branch master
Changes to be committed:
(use "git reset HEAD <file>..." to unstage)
renamed: -> README
Sin embargo, eso es equivalente a ejecutar algo como esto:
CHAPTER 2: Fundamentos de Git
$ git rm
$ git add README
Git se da cuenta que es un renombramiento implícito, así que no importa si
renombras el archivo de esa manera o a través del comando mv. La única difer-
encia real es que mv es un solo comando en vez de tres - existe por convenien-
cia. De hecho, puedes usar la herramienta que quieras para renombrar un ar-
chivo y luego realizar el proceso rm/add antes de confirmar.
Ver el Historial de Confirmaciones
Después de haber hecho varias confirmaciones, o si has clonado un repositorio
que ya tenía un histórico de confirmaciones, probablemente quieras mirar atrás
para ver qué modificaciones se han llevado a cabo. La herramienta más básica
y potente para hacer esto es el comando git log.
Estos ejemplos usan un proyecto muy sencillo llamado “simplegit”. Para clo-
nar el proyecto, ejecuta:
git clone
Cuando ejecutes git log sobre este proyecto, deberías ver una salida simi-
lar a esta:
$ git log
commit ca82a6dff817ec66f44342007202690a93763949
Author: Scott Chacon <>
Date: Mon Mar 17 21:52:11 2008 -0700
changed the version number
commit 085bb3bcb608e1e8451d4b2432f8ecbe6306e7e7
Author: Scott Chacon <>
Date: Sat Mar 15 16:40:33 2008 -0700
removed unnecessary test
commit a11bef06a3f659402fe7563abf99ad00de2209e6
Author: Scott Chacon <>
Date: Sat Mar 15 10:31:28 2008 -0700
Ver el Historial de Confirmaciones
first commit
Por defecto, si no pasas ningún parámetro, git log lista las confirmaciones
hechas sobre ese repositorio en orden cronológico inverso. Es decir, las confir-
maciones más recientes se muestran al principio. Como puedes ver, este co-
mando lista cada confirmación con su suma de comprobación SHA-1, el nom-
bre y dirección de correo del autor, la fecha y el mensaje de confirmación.
El comando git log proporciona gran cantidad de opciones para mos-
trarte exactamente lo que buscas. Aquí veremos algunas de las más usadas.
Una de las opciones más útiles es -p, que muestra las diferencias introduci-
das en cada confirmación. También puedes usar la opción -2, que hace que se
muestren únicamente las dos últimas entradas del historial:
$ git log -p -2
commit ca82a6dff817ec66f44342007202690a93763949
Author: Scott Chacon <>
Date: Mon Mar 17 21:52:11 2008 -0700
changed the version number
diff --git a/Rakefile b/Rakefile
index a874b73..8f94139 100644
--- a/Rakefile
+++ b/Rakefile
@@ -5,7 +5,7 @@ require 'rake/gempackagetask'
spec = do |s|
s.platform = Gem::Platform::RUBY = "simplegit"
- s.version = "0.1.0"
+ s.version = "0.1.1" = "Scott Chacon" = ""
s.summary = "A simple gem for using Git in Ruby code."
commit 085bb3bcb608e1e8451d4b2432f8ecbe6306e7e7
Author: Scott Chacon <>
Date: Sat Mar 15 16:40:33 2008 -0700
removed unnecessary test
diff --git a/lib/simplegit.rb b/lib/simplegit.rb
index a0a60ae..47c6340 100644
--- a/lib/simplegit.rb
+++ b/lib/simplegit.rb
@@ -18,8 +18,3 @@ class SimpleGit
CHAPTER 2: Fundamentos de Git
-if $0 == __FILE__
- git =
- puts
\ No newline at end of file
Esta opción muestra la misma información, pero añadiendo tras cada entra-
da las diferencias que le corresponden. Esto resulta muy útil para revisiones de
código, o para visualizar rápidamente lo que ha pasado en las confirmaciones
enviadas por un colaborador. También puedes usar con git log una serie de
opciones de resumen. Por ejemplo, si quieres ver algunas estadísticas de cada
confirmación, puedes usar la opción --stat:
$ git log --stat
commit ca82a6dff817ec66f44342007202690a93763949
Author: Scott Chacon <>
Date: Mon Mar 17 21:52:11 2008 -0700
changed the version number
Rakefile | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
commit 085bb3bcb608e1e8451d4b2432f8ecbe6306e7e7
Author: Scott Chacon <>
Date: Sat Mar 15 16:40:33 2008 -0700
removed unnecessary test
lib/simplegit.rb | 5 -----
1 file changed, 5 deletions(-)
commit a11bef06a3f659402fe7563abf99ad00de2209e6
Author: Scott Chacon <>
Date: Sat Mar 15 10:31:28 2008 -0700
first commit
README | 6 ++++++
Rakefile | 23 +++++++++++++++++++++++
lib/simplegit.rb | 25 +++++++++++++++++++++++++
3 files changed, 54 insertions(+)
Ver el Historial de Confirmaciones
Como puedes ver, la opción --stat imprime tras cada confirmación una lis-
ta de archivos modificados, indicando cuántos han sido modificados y cuántas
líneas han sido añadidas y eliminadas para cada uno de ellos, y un resumen de
toda esta información.
Otra opción realmente útil es --pretty, que modifica el formato de la sali-
da. Tienes unos cuantos estilos disponibles. La opción oneline imprime cada
confirmación en una única línea, lo que puede resultar útil si estás analizando
gran cantidad de confirmaciones. Otras opciones son short, full y fuller,
que muestran la salida en un formato parecido, pero añadiendo menos o más
información, respectivamente:
$ git log --pretty=oneline
ca82a6dff817ec66f44342007202690a93763949 changed the version number
085bb3bcb608e1e8451d4b2432f8ecbe6306e7e7 removed unnecessary test
a11bef06a3f659402fe7563abf99ad00de2209e6 first commit
La opción más interesante es format, que te permite especificar tu propio
formato. Esto resulta especialmente útil si estás generando una salida para que
sea analizada por otro programa —como especificas el formato explícitamente,
sabes que no cambiará en futuras actualizaciones de Git—:
$ git log --pretty=format:"%h - %an, %ar : %s"
ca82a6d - Scott Chacon, 6 years ago : changed the version number
085bb3b - Scott Chacon, 6 years ago : removed unnecessary test
a11bef0 - Scott Chacon, 6 years ago : first commit
Table 2-1 lista algunas de las opciones más útiles aceptadas por format.
TABLE 2-1. Opciones útiles de git log --pretty=format
Opción Descripción de la salida
%H Hash de la confirmación
%h Hash de la confirmación abreviado
%T Hash del árbol
%t Hash del árbol abreviado
%P Hashes de las confirmaciones padre
%p Hashes de las confirmaciones padre abreviados
CHAPTER 2: Fundamentos de Git
Opción Descripción de la salida
%an Nombre del autor
%ae Dirección de correo del autor
%ad Fecha de autoría (el formato respeta la opción -–date)
%ar Fecha de autoría, relativa
%cn Nombre del confirmador
%ce Dirección de correo del confirmador
%cd Fecha de confirmación
%cr Fecha de confirmación, relativa
%s Asunto
Puede que te estés preguntando la diferencia entre autor (author) y confir-
mador (committer). El autor es la persona que escribió originalmente el trabajo,
mientras que el confirmador es quien lo aplicó. Por tanto, si mandas un parche
a un proyecto, y uno de sus miembros lo aplica, ambos recibiréis reconocimien-
to —tú como autor, y el miembro del proyecto como confirmador—. Veremos
esta distinción en mayor profundidad en Chapter 5.
Las opciones oneline y format son especialmente útiles combinadas con
otra opción llamada --graph. Ésta añade un pequeño gráfico ASCII mostrando
tu historial de ramificaciones y uniones:
$ git log --pretty=format:"%h %s" --graph
* 2d3acf9 ignore errors from SIGCHLD on trap
* 5e3ee11 Merge branch 'master' of git://
| * 420eac9 Added a method for getting the current branch.
* | 30e367c timeout code and tests
* | 5a09431 add timeout protection to grit
* | e1193f8 support for heads with slashes in them
* d6016bc require time for xmlschema
* 11d191e Merge branch 'defunkt' into local
Este tipo de salidas serán más interesantes cuando empecemos a hablar so-
bre ramificaciones y combinaciones en el próximo capítulo.
Éstas son sólo algunas de las opciones para formatear la salida de git log
—existen muchas más. Table 2-2 lista las opciones vistas hasta ahora, y algu-
Ver el Historial de Confirmaciones
nas otras opciones de formateo que pueden resultarte útiles, así como su efec-
to sobre la salida.
TABLE 2-2. Opciones típicas de git log
Opción Descripción
-p Muestra el parche introducido en cada confirmación.
--stat Muestra estadísticas sobre los archivos modificados en ca-
da confirmación.
--shortstat Muestra solamente la línea de resumen de la opción --
--name-only Muestra la lista de archivos afectados.
--name-status Muestra la lista de archivos afectados, indicando además si
fueron añadidos, modificados o eliminados.
--abbrev-commit Muestra solamente los primeros caracteres de la suma
SHA-1, en vez de los 40 caracteres de que se compone.
--relative-date Muestra la fecha en formato relativo (por ejemplo, “2 weeks
ago” (“hace 2 semanas”)) en lugar del formato completo.
--graph Muestra un gráfico ASCII con la historia de ramificaciones y
--pretty Muestra las confirmaciones usando un formato alternativo.
Posibles opciones son oneline, short, full, fuller y format
(mediante el cual puedes especificar tu propio formato).
Limitar la Salida del Historial
Además de las opciones de formateo, git log acepta una serie de opciones
para limitar su salida —es decir, opciones que te permiten mostrar únicamente
parte de las confirmaciones—. Ya has visto una de ellas, la opción -2, que
muestra sólo las dos últimas confirmaciones. De hecho, puedes hacer -<n>,
siendo n cualquier entero, para mostrar las últimas n confirmaciones. En reali-
dad es poco probable que uses esto con frecuencia, ya que Git por defecto pagi-
na su salida para que veas cada página del historial por separado.
Sin embargo, las opciones temporales como --since (desde) y --until
(hasta) sí que resultan muy útiles. Por ejemplo, este comando lista todas las
confirmaciones hechas durante las dos últimas semanas:
$ git log --since=2.weeks
CHAPTER 2: Fundamentos de Git
Este comando acepta muchos formatos. Puedes indicar una fecha concreta
("2008-01-15"), o relativa, como "2 years 1 day 3 minutes ago" ("hace
2 años, 1 día y 3 minutos").
También puedes filtrar la lista para que muestre sólo aquellas confirma-
ciones que cumplen ciertos criterios. La opción --author te permite filtrar por
autor, y --grep te permite buscar palabras clave entre los mensajes de confir-
mación. (Ten en cuenta que si quieres aplicar ambas opciones simultánea-
mente, tienes que añadir --all-match, o el comando mostrará las confirma-
ciones que cumplan cualquiera de las dos, no necesariamente las dos a la vez.)
Otra opción útil es -S, la cual recibe una cadena y solo muestra las confirma-
ciones que cambiaron el código añadiendo o eliminando la cadena. Por ejem-
plo, si quieres encontrar la última confirmación que añadió o eliminó una refer-
encia a una función específica, puede ejecutar:
$ git log -Sfunction_name
La última opción verdaderamente útil para filtrar la salida de git log es es-
pecificar una ruta. Si especificas la ruta de un directorio o archivo, puedes limi-
tar la salida a aquellas confirmaciones que introdujeron un cambio en dichos
archivos. Ésta debe ser siempre la última opción, y suele ir precedida de dos
guiones (--) para separar la ruta del resto de opciones.
En Table 2-3 se listan estas opciones, y algunas otras bastante comunes, a
modo de referencia.
TABLE 2-3. Opciones para limitar la salida de git log
Opción Descripción
-(n) Muestra solamente las últimas n confirmaciones
--since, --after Muestra aquellas confirmaciones hechas después
de la fecha especificada.
--until, --before Muestra aquellas confirmaciones hechas antes de
la fecha especificada.
--author Muestra solo aquellas confirmaciones cuyo autor
coincide con la cadena especificada.
--committer Muestra solo aquellas confirmaciones cuyo confir-
mador coincide con la cadena especificada.
-S Muestra solo aquellas confirmaciones que añadan
o eliminen código que corresponda con la cadena
Ver el Historial de Confirmaciones
Por ejemplo, si quieres ver cuáles de las confirmaciones hechas sobre archi-
vos de prueba del código fuente de Git fueron enviadas por Junio Hamano, y no
fueron uniones, en el mes de octubre de 2008, ejecutarías algo así:
$ git log --pretty="%h - %s" --author=gitster --since="2008-10-01" \
--before="2008-11-01" --no-merges -- t/
5610e3b - Fix testcase failure when extended attributes are in use
acd3b9e - Enhance hold_lock_file_for_{update,append}() API
f563754 - demonstrate breakage of detached checkout with symbolic link HEAD
d1a43f2 - reset --hard/read-tree --reset -u: remove unmerged new paths
51a94af - Fix "checkout --track -b newbranch" on detached HEAD
b0ad11e - pull: allow "git pull origin $something:$current_branch" into an unborn branch
De las casi 40.000 confirmaciones en la historia del código fuente de Git, este
comando muestra las 6 que cumplen estas condiciones.
Deshacer Cosas
En cualquier momento puede que quieras deshacer algo. Aquí repasaremos al-
gunas herramientas básicas usadas para deshacer cambios que hayas hecho.
Ten cuidado, a veces no es posible recuperar algo luego que lo has deshecho.
Esta es una de las pocas áreas en las que Git puede perder parte de tu trabajo si
cometes un error.
Uno de las acciones más comunes a deshacer es cuando confirmas un cam-
bio antes de tiempo y olvidas agregar algún archivo, o te equivocas en el men-
saje de confirmación. Si quieres rehacer la confirmación, puedes reconfirmar
con la opción --amend:
$ git commit --amend
Este comando utiliza tu área de preparación para la confirmación. Si no has
hecho cambios desde tu última confirmación (por ejemplo, ejecutas este co-
mando justo después de tu confirmación anterior), entonces la instantánea lu-
cirá exactamente igual, y lo único que cambiarás será el mensaje de confirma-
Se lanzará el mismo editor de confirmación, pero verás que ya incluye el
mensaje de tu confirmación anterior. Puedes editar el mensaje como siempre y
se sobreescribirá tu confirmación anterior.
Por ejemplo, si confirmas y luego te das cuenta que olvidaste preparar los
cambios de un archivo que querías incluir en esta confirmación, puedes hacer
lo siguiente:
CHAPTER 2: Fundamentos de Git
$ git commit -m 'initial commit'
$ git add forgotten_file
$ git commit --amend
Al final terminarás con una sola confirmación - la segunda confirmación re-
emplaza el resultado de la primera.
Deshacer un Archivo Preparado
Las siguientes dos secciones demuestran cómo lidiar con los cambios de tu
área de preparación y tú directorio de trabajo. Afortunadamente, el comando
que usas para determinar el estado de esas dos áreas también te recuerda có-
mo deshacer los cambios en ellas. Por ejemplo, supongamos que has cambiado
dos archivos y que quieres confirmarlos como dos cambios separados, pero ac-
cidentalmente has escrito git add * y has preparado ambos. ¿Cómo puedes
sacar del área de preparación uno de ellos? El comando git status te recuer-
da cómo:
$ git add .
$ git status
On branch master
Changes to be committed:
(use "git reset HEAD <file>..." to unstage)
renamed: -> README
Justo debajo del texto “Changes to be committed” (“Cambios a ser confir-
mados”, en inglés), verás que dice que uses git reset HEAD <file>... para
deshacer la preparación. Por lo tanto, usemos el consejo para deshacer la pre-
paración del archivo
$ git reset HEAD
Unstaged changes after reset:
$ git status
On branch master
Changes to be committed:
(use "git reset HEAD <file>..." to unstage)
renamed: -> README
Deshacer Cosas
Changes not staged for commit:
(use "git add <file>..." to update what will be committed)
(use "git checkout -- <file>..." to discard changes in working directory)
El comando es un poco raro, pero funciona. El archivo
esta modificado y, nuevamente, no preparado.
A pesar de que git reset puede ser un comando peligroso si lo llamas con
--hard, en este caso el archivo que está en tu directorio de trabajo no se
toca. Ejecutar git reset sin opciones no es peligroso - solo toca el área de
Por ahora lo único que necesitas saber sobre el comando git reset es esta
invocación mágica. Entraremos en mucho más detalle sobre qué hace reset y
como dominarlo para que haga cosas realmente interesantes en “Reset De-
Deshacer un Archivo Modificado
¿Qué tal si te das cuenta que no quieres mantener los cambios del archivo CON- ¿Cómo puedes restaurarlo fácilmente - volver al estado en el
que estaba en la última confirmación (o cuando estaba recién clonado, o como
sea que haya llegado a tu directorio de trabajo)? Afortunadamente, git sta-
tus también te dice cómo hacerlo. En la salida anterior, el área no preparada
lucía así:
Changes not staged for commit:
(use "git add <file>..." to update what will be committed)
(use "git checkout -- <file>..." to discard changes in working directory)
Allí se te indica explícitamente como descartar los cambios que has hecho.
Hagamos lo que nos dice:
$ git checkout --
$ git status
On branch master
Changes to be committed:
(use "git reset HEAD <file>..." to unstage)
CHAPTER 2: Fundamentos de Git
renamed: -> README
Ahora puedes ver que los cambios se han revertido.
Es importante entender que git checkout -- [archivo] es un comando
peligroso. Cualquier cambio que le hayas hecho a ese archivo desapare-
cerá - acabas de sobreescribirlo con otro archivo. Nunca utilices este co-
mando a menos que estés absolutamente seguro de que ya no quieres el
Para mantener los cambios que has hecho y a la vez deshacerte del archivo
temporalmente, hablaremos sobre cómo esconder archivos (stashing, en in-
glés) y sobre ramas en Chapter 3; normalmente, estas son las mejores maneras
de hacerlo.
Recuerda, todo lo que esté confirmado en Git puede recuperarse. Incluso
commits que estuvieron en ramas que han sido eliminadas o commits que fuer-
on sobreescritos con --amend pueden recuperarse (véase “Data Recovery”
para recuperación de datos). Sin embargo, es posible que no vuelvas a ver ja-
más cualquier cosa que pierdas y que nunca haya sido confirmada.
Trabajar con Remotos
Para poder colaborar en cualquier proyecto Git, necesitas saber cómo gestionar
repositorios remotos. Los repositorios remotos son versiones de tu proyecto
que están hospedadas en Internet en cualquier otra red. Puedes tener varios de
ellos, y en cada uno tendrás generalmente permisos de solo lectura o de lectura
y escritura. Colaborar con otras personas implica gestionar estos repositorios
remotos y enviar y traer datos de ellos cada vez que necesites compartir tu tra-
bajo. Gestionar repositorios remotos incluye saber cómo añadir un repositorio
remoto, eliminar los remotos que ya no son válidos, gestionar varias ramas re-
motas y definir si deben rastrearse o no, y más. En esta sección, trataremos al-
gunas de estas habilidades de gestión de remotos.
Ver Tus Remotos
Para ver los remotos que tienes configurados, debes ejecutar el comando git
remote. Mostrará los nombres de cada uno de los remotos que tienes especifi-
cados. Si has clonado tu repositorio, deberías ver al menos origin (origen, en
inglés) - este es el nombre que por defecto Git le da al servidor del que has clo-
Trabajar con Remotos
$ git clone
Cloning into 'ticgit'...
remote: Reusing existing pack: 1857, done.
remote: Total 1857 (delta 0), reused 0 (delta 0)
Receiving objects: 100% (1857/1857), 374.35 KiB | 268.00 KiB/s, done.
Resolving deltas: 100% (772/772), done.
Checking connectivity... done.
$ cd ticgit
$ git remote
También puedes pasar la opción -v, la cual muestra las URLs que Git ha aso-
ciado al nombre y que serán usadas al leer y escribir en ese remoto:
$ git remote -v
origin (fetch)
origin (push)
Si tienes más de un remoto, el comando los listará todos. Por ejemplo, un
repositorio con múltiples remotos para trabajar con distintos colaboradores
podría verse de la siguiente manera.
$ cd grit
$ git remote -v
bakkdoor (fetch)
bakkdoor (push)
cho45 (fetch)
cho45 (push)
defunkt (fetch)
defunkt (push)
koke git:// (fetch)
koke git:// (push)
origin (fetch)
origin (push)
Esto significa que podemos traer contribuciones de cualquiera de estos
usuarios fácilmente. Es posible que también tengamos permisos para enviar
datos a algunos, aunque no podemos saberlo desde aquí.
Fíjate que estos remotos usan distintos protocolos; hablaremos sobre ello
más adelante, en “Configurando Git en un servidor”.
CHAPTER 2: Fundamentos de Git
Añadir Repositorios Remotos
En secciones anteriores hemos mencionado y dado alguna demostración de
cómo añadir repositorios remotos. Ahora veremos explícitamente cómo hacer-
lo. Para añadir un remoto nuevo y asociarlo a un nombre que puedas referen-
ciar fácilmente, ejecuta git remote add [nombre] [url]:
$ git remote
$ git remote add pb
$ git remote -v
origin (fetch)
origin (push)
pb (fetch)
pb (push)
A partir de ahora puedes usar el nombre pb en la línea de comandos en lugar
de la URL entera. Por ejemplo, si quieres traer toda la información que tiene
Paul pero tú aun no tienes en tu repositorio, puedes ejecutar git fetch pb:
$ git fetch pb
remote: Counting objects: 43, done.
remote: Compressing objects: 100% (36/36), done.
remote: Total 43 (delta 10), reused 31 (delta 5)
Unpacking objects: 100% (43/43), done.
* [new branch] master -> pb/master
* [new branch] ticgit -> pb/ticgit
La rama maestra de Paul ahora es accesible localmente con el nombre pb/
master - puedes combinarla con alguna de tus ramas, o puedes crear una rama
local en ese punto si quieres inspeccionarla. (Hablaremos con más detalle acer-
ca de qué son las ramas y cómo utilizarlas en Chapter 3.)
Traer y Combinar Remotos
Como hemos visto hasta ahora, para obtener datos de tus proyectos remotos
puedes ejecutar:
$ git fetch [remote-name]
Trabajar con Remotos
El comando irá al proyecto remoto y se traerá todos los datos que aun no
tienes de dicho remoto. Luego de hacer esto, tendrás referencias a todas las
ramas del remoto, las cuales puedes combinar e inspeccionar cuando quieras.
Si clonas un repositorio, el comando de clonar automáticamente añade ese
repositorio remoto con el nombre “origin”. Por lo tanto, git fetch origin se
trae todo el trabajo nuevo que ha sido enviado a ese servidor desde que lo clo-
naste (o desde la última vez que trajiste datos). Es importante destacar que el
comando git fetch solo trae datos a tu repositorio local - ni lo combina auto-
máticamente con tu trabajo ni modifica el trabajo que llevas hecho. La combi-
nación con tu trabajo debes hacerla manualmente cuando estés listo.
Si has configurado una rama para que rastree una rama remota (más infor-
mación en la siguiente sección y en Chapter 3), puedes usar el comando git
pull para traer y combinar automáticamente la rama remota con tu rama ac-
tual. Es posible que este sea un flujo de trabajo mucho más cómodo y fácil para
ti; y por defecto, el comando git clone le indica automáticamente a tu rama
maestra local que rastree la rama maestra remota (o como se llame la rama por
defecto) del servidor del que has clonado. Generalmente, al ejecutar git pull
traerás datos del servidor del que clonaste originalmente y se intentará combi-
nar automáticamente la información con el código en el que estás trabajando.
Enviar a Tus Remotos
Cuando tienes un proyecto que quieres compartir, debes enviarlo a un servidor.
El comando para hacerlo es simple: git push [nombre-remoto] [nombre-
rama]. Si quieres enviar tu rama master a tu servidor origin (recuerda, clonar
un repositorio establece esos nombres automáticamente), entonces puedes
ejecutar el siguiente comando y se enviarán todos los commits que hayas hecho
al servidor:
$ git push origin master
Este comando solo funciona si clonaste de un servidor sobre el que tienes
permisos de escritura y si nadie más ha enviado datos por el medio. Si alguien
más clona el mismo repositorio que tú y envía información antes que tú, tu en-
vío será rechazado. Tendrás que traerte su trabajo y combinarlo con el tuyo an-
tes de que puedas enviar datos al servidor. Para información más detallada so-
bre cómo enviar datos a servidores remotos, véase Chapter 3.
CHAPTER 2: Fundamentos de Git
Inspeccionar un Remoto
Si quieres ver más información acerca de un remoto en particular, puedes eje-
cutar el comando git remote show [nombre-remoto]. Si ejecutas el co-
mando con un nombre en particular, como origin, verás algo como lo si-
$ git remote show origin
* remote origin
Fetch URL:
Push URL:
HEAD branch: master
Remote branches:
master tracked
dev-branch tracked
Local branch configured for 'git pull':
master merges with remote master
Local ref configured for 'git push':
master pushes to master (up to date)
El comando lista la URL del repositorio remoto y la información del rastreo
de ramas. El comando te indica claramente que si estás en la rama maestra y
ejecutas el comando git pull, automáticamente combinará la rama maestra
remota luego de haber traído toda la información de ella. También lista todas
las referencias remotas de las que ha traído datos.
Ejemplos como este son los que te encontrarás normalmente. Sin embargo,
si usas Git de forma más avanzada, puede que obtengas mucha más informa-
ción de un git remote show:
$ git remote show origin
* remote origin
Fetch URL:
Push URL:
HEAD branch: master
Remote branches:
master tracked
dev-branch tracked
markdown-strip tracked
issue-43 new (next fetch will store in remotes/origin)
issue-45 new (next fetch will store in remotes/origin)
refs/remotes/origin/issue-11 stale (use 'git remote prune' to remove)
Local branches configured for 'git pull':
dev-branch merges with remote dev-branch
master merges with remote master
Trabajar con Remotos
Local refs configured for 'git push':
dev-branch pushes to dev-branch (up to date)
markdown-strip pushes to markdown-strip (up to date)
master pushes to master (up to date)
Este comando te indica a cuál rama enviarás información automáticamente
cada vez que ejecutas git push, dependiendo de la rama en la que estés. Tam-
bién te muestra cuáles ramas remotas no tienes aun, cuáles ramas remotas
tienes que han sido eliminadas del servidor, y varias ramas que serán combina-
das automáticamente cuando ejecutes git pull.
Eliminar y Renombrar Remotos
Si quieres cambiar el nombre de la referencia de un remoto puedes ejecutar
git remote rename. Por ejemplo, si quieres cambiar el nombre de pb a paul,
puedes hacerlo con git remote rename:
$ git remote rename pb paul
$ git remote
Es importante destacar que al hacer esto también cambias el nombre de las
ramas remotas. Por lo tanto, lo que antes estaba referenciado como pb/
master ahora lo está como paul/master.
Si por alguna razón quieres eliminar un remoto - has cambiado de servidor o
no quieres seguir utilizando un mirror, o quizás un colaborador a dejado de tra-
bajar en el proyecto - puedes usar git remote rm:
$ git remote rm paul
$ git remote
Como muchos VCS, Git tiene la posibilidad de etiquetar puntos específicos del
historial como importantes. Esta funcionalidad se usa típicamente para marcar
versiones de lanzamiento (v1.0, por ejemplo). En esta sección, aprenderás có-
mo listar las etiquetas disponibles, cómo crear nuevas etiquetas y cuáles son
los distintos tipos de etiquetas.
CHAPTER 2: Fundamentos de Git
Listar Tus Etiquetas
Listar las etiquetas disponibles en Git es sencillo. Simplemente escribe git
$ git tag
Este comando lista las etiquetas en orden alfabético; el orden en el que
aparecen no tiene mayor importancia.
También puedes buscar etiquetas con un patrón particular. El repositorio del
código fuente de Git, por ejemplo, contiene más de 500 etiquetas. Si solo te in-
teresa ver la serie 1.8.5, puedes ejecutar:
$ git tag -l 'v1.8.5*'
Crear Etiquetas
Git utiliza dos tipos principales de etiquetas: ligeras y anotadas.
Una etiqueta ligera es muy parecido a una rama que no cambia - simple-
mente es un puntero a un commit específico.
Sin embargo, las etiquetas anotadas se guardan en la base de datos de Git
como objetos enteros. Tienen un checksum; contienen el nombre del etiqueta-
dor, correo electrónico y fecha; tienen un mensaje asociado; y pueden ser fir-
madas y verificadas con GNU Privacy Guard (GPG). Normalmente se recomienda
que crees etiquetas anotadas, de manera que tengas toda esta información;
pero si quieres una etiqueta temporal o por alguna razón no estás interesado
en esa información, entonces puedes usar las etiquetas ligeras.
Etiquetas Anotadas
Crear una etiqueta anotada en Git es sencillo. La forma más fácil de hacer es
especificar la opción -a cuando ejecutas el comando tag:
$ git tag -a v1.4 -m 'my version 1.4'
$ git tag
La opción -m especifica el mensaje de la etiqueta, el cual es guardado junto
con ella. Si no especificas el mensaje de una etiqueta anotada, Git abrirá el edi-
tor de texto para que lo escribas.
Puedes ver la información de la etiqueta junto con el commit que está eti-
quetado al usar el comando git show:
$ git show v1.4
tag v1.4
Tagger: Ben Straub <>
Date: Sat May 3 20:19:12 2014 -0700
my version 1.4
commit ca82a6dff817ec66f44342007202690a93763949
Author: Scott Chacon <>
Date: Mon Mar 17 21:52:11 2008 -0700
changed the version number
El comando muestra la información del etiquetador, la fecha en la que el
commit fue etiquetado y el mensaje de la etiquetar, antes de mostrar la infor-
mación del commit.
Etiquetas Ligeras
La otra forma de etiquetar un commit es mediante una etiqueta ligera. Una eti-
queta ligera no es más que el checksum de un commit guardado en un archivo -
no incluye más información. Para crear una etiqueta ligera, no pases las op-
ciones -a, -s ni -m:
CHAPTER 2: Fundamentos de Git
$ git tag v1.4-lw
$ git tag
Esta vez, si ejecutas git show sobre la etiqueta, no verás la información
adicional. El comando solo mostrará el commit:
$ git show v1.4-lw
commit ca82a6dff817ec66f44342007202690a93763949
Author: Scott Chacon <>
Date: Mon Mar 17 21:52:11 2008 -0700
changed the version number
Etiquetado Tardío
También puedes etiquetar commits mucho tiempo después de haberlos hecho.
Supongamos que tu historial luce como el siguiente:
$ git log --pretty=oneline
15027957951b64cf874c3557a0f3547bd83b3ff6 Merge branch 'experiment'
a6b4c97498bd301d84096da251c98a07c7723e65 beginning write support
0d52aaab4479697da7686c15f77a3d64d9165190 one more thing
6d52a271eda8725415634dd79daabbc4d9b6008e Merge branch 'experiment'
0b7434d86859cc7b8c3d5e1dddfed66ff742fcbc added a commit function
4682c3261057305bdd616e23b64b0857d832627b added a todo file
166ae0c4d3f420721acbb115cc33848dfcc2121a started write support
9fceb02d0ae598e95dc970b74767f19372d61af8 updated rakefile
964f16d36dfccde844893cac5b347e7b3d44abbc commit the todo
8a5cbc430f1a9c3d00faaeffd07798508422908a updated readme
Ahora, supongamos que olvidaste etiquetar el proyecto en su versión v1.2, la
cual corresponde al commit “updated rakefile”. Igual puedes etiquetarlo. Para
etiquetar un commit, debes especificar el checksum del commit (o parte de él)
al final del comando:
$ git tag -a v1.2 9fceb02
Puedes ver que has etiquetado el commit:
$ git tag
$ git show v1.2
tag v1.2
Tagger: Scott Chacon <>
Date: Mon Feb 9 15:32:16 2009 -0800
version 1.2
commit 9fceb02d0ae598e95dc970b74767f19372d61af8
Author: Magnus Chacon <>
Date: Sun Apr 27 20:43:35 2008 -0700
updated rakefile
Compartir Etiquetas
Por defecto, el comando git push no transfiere las etiquetas a los servidores
remotos. Debes enviar las etiquetas de forma explícita al servidor luego de que
las hayas creado. Este proceso es similar al de compartir ramas remotas -
puede ejecutar git push origin [etiqueta].
$ git push origin v1.5
Counting objects: 14, done.
Delta compression using up to 8 threads.
Compressing objects: 100% (12/12), done.
Writing objects: 100% (14/14), 2.05 KiB | 0 bytes/s, done.
Total 14 (delta 3), reused 0 (delta 0)
* [new tag] v1.5 -> v1.5
Si quieres enviar varias etiquetas a la vez, puedes usar la opción --tags del
comando git push. Esto enviará al servidor remoto todas las etiquetas que
aun no existen en él.
CHAPTER 2: Fundamentos de Git
$ git push origin --tags
Counting objects: 1, done.
Writing objects: 100% (1/1), 160 bytes | 0 bytes/s, done.
Total 1 (delta 0), reused 0 (delta 0)
* [new tag] v1.4 -> v1.4
* [new tag] v1.4-lw -> v1.4-lw
Por lo tanto, cuando alguien clone o traiga información de tu repositorio,
también obtendrá todas las etiquetas.
Sacar una Etiqueta
En Git, no puedes sacar (check out) una etiqueta, pues no es algo que puedas
mover. Si quieres colocar en tu directorio de trabajo una versión de tu reposi-
torio que coincida con alguna etiqueta, debes crear una rama nueva en esa eti-
$ git checkout -b version2 v2.0.0
Switched to a new branch 'version2'
Obviamente, si haces esto y luego confirmas tus cambios, tu rama version2
será ligeramente distinta a tu etiqueta v2.0.0 puesto que incluirá tus nuevos
cambios; así que ten cuidado.
Git Aliases
Before we finish this chapter on basic Git, there’s just one little tip that can
make your Git experience simpler, easier, and more familiar: aliases. We won’t
refer to them or assume you’ve used them later in the book, but you should
probably know how to use them.
Git doesn’t automatically infer your command if you type it in partially. If
you don’t want to type the entire text of each of the Git commands, you can
easily set up an alias for each command using git config. Here are a couple
of examples you may want to set up:
$ git config --global checkout
$ git config --global branch
$ git config --global commit
$ git config --global status
Git Aliases
This means that, for example, instead of typing git commit, you just need
to type git ci. As you go on using Git, you’ll probably use other commands
frequently as well; don’t hesitate to create new aliases.
This technique can also be very useful in creating commands that you think
should exist. For example, to correct the usability problem you encountered
with unstaging a file, you can add your own unstage alias to Git:
$ git config --global alias.unstage 'reset HEAD --'
This makes the following two commands equivalent:
$ git unstage fileA
$ git reset HEAD fileA
This seems a bit clearer. It’s also common to add a last command, like this:
$ git config --global alias.last 'log -1 HEAD'
This way, you can see the last commit easily:
$ git last
commit 66938dae3329c7aebe598c2246a8e6af90d04646
Author: Josh Goebel <>
Date: Tue Aug 26 19:48:51 2008 +0800
test for current head
Signed-off-by: Scott Chacon <>
As you can tell, Git simply replaces the new command with whatever you
alias it for. However, maybe you want to run an external command, rather than
a Git subcommand. In that case, you start the command with a ! character. This
is useful if you write your own tools that work with a Git repository. We can
demonstrate by aliasing git visual to run gitk:
$ git config --global alias.visual "!gitk"
CHAPTER 2: Fundamentos de Git
En este momento puedes hacer todas las operaciones básicas de Git a nivel lo-
cal: Crear o clonar un repositorio, hacer cambios, preparar y confirmar esos
cambios y ver la historia de los cambios en el repositorio. A continuación cu-
briremos la mejor característica de Git: Su modelo de ramas.
Ramificaciones en Git
Cualquier sistema de control de versiones moderno tiene algún mecanismo
para soportar distintos ramales. Cuando hablamos de ramificaciones, significa
que tú has tomado la rama principal de desarrollo (master) y a partir de ahí has
continuado trabajando sin seguir la rama principal de desarrollo. En muchas
sistemas de control de versiones este proceso es costoso, pues a menudo re-
quiere crear una nueva copia del código, lo cual puede tomar mucho tiempo
cuando se trata de proyectos grandes.
Algunas personas resaltan que uno de los puntos más fuertes de Git es su
sistema de ramificaciones y lo cierto es que esto le hace resaltar sobre los otros
sistemas de control de versiones. ¿Por qué esto es tan importante? La forma en
la que Git maneja las ramificaciones es increíblemente rápida, haciendo así de
las operaciones de ramificación algo casi instantáneo, al igual que el avance o
el retroceso entre distintas ramas, lo cual también es tremendamente rápido. A
diferencia de otros sistemas de control de versiones, Git promueve un ciclo de
desarrollo donde las ramas se crean y se unen ramas entre sí, incluso varias ve-
ces en el mismo día. Entender y manejar esta opción te proporciona una poder-
osa y exclusiva herramienta que puede, literalmente, cambiar la forma en la
que desarrollas.
¿Qué es una rama?
Para entender realmente cómo ramifica Git, previamente hemos de examinar la
forma en que almacena sus datos.
Recordando lo citado en Chapter 1, Git no los almacena de forma incremen-
tal (guardando solo diferencias), sino que los almacena como una serie de in-
stantáneas (copias puntuales de los archivos completos, tal y como se encuen-
tran en ese momento).
En cada confirmación de cambios (commit), Git almacena una instantánea
de tu trabajo preparado. Dicha instantánea contiene además unos metadatos
con el autor y el mensaje explicativo, y uno o varios apuntadores a las confir-
Una conrmación y
sus árboles
maciones (commit) que sean padres directos de esta (un padre en los casos de
confirmación normal, y múltiples padres en los casos de estar confirmando una
fusión (merge) de dos o más ramas).
Para ilustrar esto, vamos a suponer, por ejemplo, que tienes una carpeta con
tres archivos, que preparas (stage) todos ellos y los confirmas (commit). Al pre-
parar los archivos, Git realiza una suma de control de cada uno de ellos (un re-
sumen SHA-1, tal y como se mencionaba en Chapter 1), almacena una copia de
cada uno en el repositorio (estas copias se denominan “blobs”), y guarda cada
suma de control en el área de preparación (staging area):
$ git add README test.rb LICENSE
$ git commit -m 'initial commit of my project'
Cuando creas una confirmación con el comando git commit, Git realiza su-
mas de control de cada subdirectorio (en el ejemplo, solamente tenemos el di-
rectorio principal del proyecto), y las guarda como objetos árbol en el reposi-
torio Git. Después, Git crea un objeto de confirmación con los metadatos perti-
nentes y un apuntador al objeto árbol raiz del proyecto.
En este momento, el repositorio de Git contendrá cinco objetos: un “blob
para cada uno de los tres archivos, un árbol con la lista de contenidos del direc-
torio (más sus respectivas relaciones con los “blobs”), y una confirmación de
cambios (commit) apuntando a la raiz de ese árbol y conteniendo el resto de
metadatos pertinentes.
CHAPTER 3: Ramificaciones en Git
Conrmaciones y
sus predecesoras
Una rama y su
historial de
Si haces más cambios y vuelves a confirmar, la siguiente confirmación guar-
dará un apuntador su confirmación precedente.
Una rama Git es simplemente un apuntador móvil apuntando a una de esas
confirmaciones. La rama por defecto de Git es la rama master. Con la primera
confirmación de cambios que realicemos, se creará esta rama principal master
apuntando a dicha confirmación. En cada confirmación de cambios que reali-
cemos, la rama irá avanzando automáticamente.
La rama “master” en Git no es una rama especial. Es como cualquier otra
rama. La única razón por la cual aparece en casi todos los repositorioes es
porque es la que crea por defecto el comando git init y la gente no se
molesta en cambiarle el nombre.
¿Qué es una rama?
Dos ramas
apuntando al mismo
grupo de
Crear una Rama Nueva
¿Qué sucede cuando creas una nueva rama? Bueno…, simplemente se crea un
nuevo apuntador para que lo puedas mover libremente. Por ejemplo, suponga-
mos que quieres crear una rama nueva denominada “testing”. Para ello, usarás
el comando git branch:
$ git branch testing
Esto creará un nuevo apuntador apuntando a la misma confirmación donde
estés actualmente.
Y, ¿cómo sabe Git en qué rama estás en este momento? Pues…, mediante un
apuntador especial denominado HEAD. Aunque es preciso comentar que este
HEAD es totalmente distinto al concepto de HEAD en otros sistemas de control
de cambios como Subversion o CVS. En Git, es simplemente el apuntador a la
rama local en la que tú estés en ese momento, en este caso la rama master;
pues el comando git branch solamente crea una nueva rama, y no salta a di-
cha rama.
CHAPTER 3: Ramificaciones en Git
Apuntador HEAD a
la rama donde estás
Esto puedes verlo fácilmente al ejecutar el comando git log para que te
muestre a dónde apunta cada rama. Esta opción se llama --decorate.
$ git log --oneline --decorate
f30ab (HEAD, master, testing) add feature #32 - ability to add new
34ac2 fixed bug #1328 - stack overflow under certain conditions
98ca9 initial commit of my project
Puedes ver que las ramas “master” y “testing” están junto a la confirmación
Cambiar de Rama
Para saltar de una rama a otra, tienes que utilizar el comando git checkout.
Hagamos una prueba, saltando a la rama testing recién creada:
$ git checkout testing
Esto mueve el apuntador HEAD a la rama testing.
¿Qué es una rama?
El apuntador HEAD
apunta a la rama
La rama apuntada
por HEAD avanza
con cada
conrmación de
¿Cuál es el significado de todo esto? Bueno… lo veremos tras realizar otra
confirmación de cambios:
$ vim test.rb
$ git commit -a -m 'made a change'
Observamos algo interesante: la rama testing avanza, mientras que la
rama master permanece en la confirmación donde estaba cuando lanzaste el
comando git checkout para saltar. Volvamos ahora a la rama master:
CHAPTER 3: Ramificaciones en Git
HEAD apunta a otra
rama cuando
hacemos un salto
$ git checkout master
Este comando realiza dos acciones: Mueve el apuntador HEAD de nuevo a la
rama master, y revierte los archivos de tu directorio de trabajo; dejándolos tal
y como estaban en la última instantánea confirmada en dicha rama master. Es-
to supone que los cambios que hagas desde este momento en adelante diver-
girán de la antigua versión del proyecto. Básicamente, lo que se está haciendo
es rebobinar el trabajo que habías hecho temporalmente en la rama testing;
de tal forma que puedas avanzar en otra dirección diferente.
Es importante destacar que cuando saltas a una rama en Git, los archivos
de tu directorio de trabajo cambian. Si saltas a una rama antigua, tu di-
rectorio de trabajo retrocederá para verse como lo hacía la última vez que
confirmaste un cambio en dicha rama. Si Git no puede hacer el cambio
limpiamente, no te dejará saltar.
Haz algunos cambios más y confírmalos:
$ vim test.rb
$ git commit -a -m 'made other changes'
Ahora el historial de tu proyecto diverge (ver Figure 3-9). Has creado una
rama y saltado a ella, has trabajado sobre ella; has vuelto a la rama original, y
has trabajado también sobre ella. Los cambios realizados en ambas sesiones de
trabajo están aislados en ramas independientes: puedes saltar libremente de
¿Qué es una rama?
Los registros de las
ramas divergen
una a otra según estimes oportuno. Y todo ello simplemente con tres coman-
dos: git branch, git checkout y git commit.
También puedes ver esto fácilmente utilizando el comando git log. Si eje-
cutas git log --oneline --decorate --graph --all te mostrará el his-
torial de tus confirmaciones, indicando dónde están los apuntadores de tus
ramas y como ha divergido tu historial.
$ git log --oneline --decorate --graph --all
* c2b9e (HEAD, master) made other changes
| * 87ab2 (testing) made a change
* f30ab add feature #32 - ability to add new formats to the
* 34ac2 fixed bug #1328 - stack overflow under certain conditions
* 98ca9 initial commit of my project
Debido a que una rama Git es realmente un simple archivo que contiene los
40 caracteres de una suma de control SHA-1, (representando la confirmación de
cambios a la que apunta), no cuesta nada el crear y destruir ramas en Git. Crear
una nueva rama es tan rápido y simple como escribir 41 bytes en un archivo, (40
caracteres y un retorno de carro).
Esto contrasta fuertemente con los métodos de ramificación usados por
otros sistemas de control de versiones, en los que crear una rama nueva su-
CHAPTER 3: Ramificaciones en Git
pone el copiar todos los archivos del proyecto a un directorio adicional nuevo.
Esto puede llevar segundos o incluso minutos, dependiendo del tamaño del
proyecto; mientras que en Git el proceso es siempre instantáneo. Y, además, de-
bido a que se almacenan también los nodos padre para cada confirmación, el
encontrar las bases adecuadas para realizar una fusión entre ramas es un proc-
eso automático y generalmente sencillo de realizar. Animando así a los desar-
rolladores a utilizar ramificaciones frecuentemente.
Vamos a ver el por qué merece la pena hacerlo así.
Procedimientos Básicos para Ramificar y Fusionar
Vamos a presentar un ejemplo simple de ramificar y de fusionar, con un flujo de
trabajo que se podría presentar en la realidad. Imagina que sigues los si-
quientes pasos:
1. Trabajas en un sitio web.
2. Creas una rama para un nuevo tema sobre el que quieres trabajar.
3. Realizas algo de trabajo en esa rama.
En este momento, recibes una llamada avisándote de un problema crítico
que has de resolver. Y sigues los siguientes pasos:
1. Vuelves a la rama de producción original.
2. Creas una nueva rama para el problema crítico y lo resuelves trabajando
en ella.
3. Tras las pertinentes pruebas, fusionas (merge) esa rama y la envías (push)
a la rama de producción.
4. Vuelves a la rama del tema en que andabas antes de la llamada y contin-
uas tu trabajo.
Procedimientos Básicos de Ramificación
Imagina que estas trabajando en un proyecto y tienes un par de confirmaciones
(commit) ya realizadas.
Procedimientos Básicos para Ramificar y Fusionar
Un registro de
conrmaciones corto
y sencillo
Crear un apuntador
a la rama nueva
Decides trabajar en el problema #53, según el sistema que tu compañía uti-
liza para llevar seguimiento de los problemas. Para crear una nueva rama y sal-
tar a ella, en un solo paso, puedes utilizar el comando git checkout con la
opción -b:
$ git checkout -b iss53
Switched to a new branch "iss53"
Esto es un atajo a:
$ git branch iss53
$ git checkout iss53
CHAPTER 3: Ramificaciones en Git
La rama iss53 ha
avanzado con tu
Trabajas en el sitio web y haces algunas confirmaciones de cambios (com-
mits). Con ello avanzas la rama iss53, que es la que tienes activada (checked
out) en este momento (es decir, a la que apunta HEAD):
$ vim index.html
$ git commit -a -m 'added a new footer [issue 53]'
Entonces, recibes una llamada avisándote de otro problema urgente en el
sitio web y debes resolverlo inmediatamente. Al usar Git, no necesitas mezclar
el nuevo problema con los cambios que ya habías realizado sobre el problema
#53; ni tampoco perder tiempo revirtiendo esos cambios para poder trabajar
sobre el contenido que está en producción. Basta con saltar de nuevo a la rama
master y continuar trabajando a partir de allí.
Pero, antes de poder hacer eso, hemos de tener en cuenta que si tenenmos
cambios aún no confirmados en el directorio de trabajo o en el área de prepara-
ción, Git no nos permitirá saltar a otra rama con la que podríamos tener conflic-
tos. Lo mejor es tener siempre un estado de trabajo limpio y despejado antes
de saltar entre ramas. Y, para ello, tenemos algunos procedimientos (stash y
corregir confirmaciones), que vamos a ver más adelante en “Stashing and
Cleaning”. Por ahora, como tenemos confirmados todos los cambios, pode-
mos saltar a la rama master sin problemas:
$ git checkout master
Switched to branch 'master'
Tras esto, tendrás el directorio de trabajo exactamente igual a como estaba
antes de comenzar a trabajar sobre el problema #53 y podrás concentrarte en el
nuevo problema urgente. Es importante recordar que Git revierte el directorio
Procedimientos Básicos para Ramificar y Fusionar
Rama hotfix
basada en la rama
master original
de trabajo exactamente al estado en que estaba en la confirmación (commit)
apuntada por la rama que activamos (checkout) en cada momento. Git añade,
quita y modifica archivos automáticamente para asegurar que tu copia de tra-
bajo luce exactamente como lucía la rama en la última confirmación de cam-
bios realizada sobre ella.
A continuación, es momento de resolver el problema urgente. Vamos a crear
una nueva rama hotfix, sobre la que trabajar hasta resolverlo:
$ git checkout -b hotfix
Switched to a new branch 'hotfix'
$ vim index.html
$ git commit -a -m 'fixed the broken email address'
[hotfix 1fb7853] fixed the broken email address
1 file changed, 2 insertions(+)
Puedes realizar las pruebas oportunas, asegurarte que la solución es correc-
ta, e incorporar los cambios a la rama master para ponerlos en producción. Es-
to se hace con el comando git merge:
$ git checkout master
$ git merge hotfix
Updating f42c576..3a0874c
index.html | 2 ++
1 file changed, 2 insertions(+)
CHAPTER 3: Ramificaciones en Git
Tras la fusión
(merge), la rama
master apunta al
mismo sitio que la
rama hotfix.
Notarás la frase “Fast forward” (“Avance rápido, en inglés) que aparece en la
salida del comando. Git ha movido el apuntador hacia adelante, ya que la con-
firmación apuntada en la rama donde has fusionado estaba directamente arri-
ba respecto a la confirmación actual. Dicho de otro modo: cuando intentas fu-
sionar una confirmación con otra confirmación accesible siguiendo directa-
mente el historial de la primera; Git simplifica las cosas avanzando el puntero,
ya que no hay ningún otro trabajo divergente a fusionar. Esto es lo que se de-
nomina “avance rápido” (“fast forward”).
Ahora, los cambios realizados están ya en la instantánea (snapshot) de la
confirmación (commit) apuntada por la rama master. Y puedes desplegarlos.
Tras haber resuelto el problema urgente que había interrumpido tu trabajo,
puedes volver a donde estabas. Pero antes, es importante borrar la rama hot-
fix, ya que no la vamos a necesitar más, puesto que apunta exactamente al
mismo sitio que la rama master. Esto lo puedes hacer con la opción -d del co-
mando git branch:
$ git branch -d hotfix
Deleted branch hotfix (3a0874c).
Y, con esto, ya estás listo para regresar al trabajo sobre el problema #53.
Procedimientos Básicos para Ramificar y Fusionar
La rama iss53
puede avanzar
$ git checkout iss53
Switched to branch "iss53"
$ vim index.html
$ git commit -a -m 'finished the new footer [issue 53]'
[iss53 ad82d7a] finished the new footer [issue 53]
1 file changed, 1 insertion(+)
Cabe destacar que todo el trabajo realizado en la rama hotfix no está en
los archivos de la rama iss53. Si fuera necesario agregarlos, puedes fusionar
(merge) la rama master sobre la rama iss53 utilizando el comando git
merge master, o puedes esperar hasta que decidas fusionar (merge) la rama
iss53 a la rama master.
Procedimientos Básicos de Fusión
Supongamos que tu trabajo con el problema #53 ya está completo y listo para
fusionarlo (merge) con la rama master. Para ello, de forma similar a como an-
tes has hecho con la rama hotfix, vas a fusionar la rama iss53. Simplemente,
activa (checkout) la rama donde deseas fusionar y lanza el comando git
$ git checkout master
Switched to branch 'master'
$ git merge iss53
Merge made by the 'recursive' strategy.
CHAPTER 3: Ramificaciones en Git
Git identica
automáticamente el
mejor ancestro
común para realizar
la fusión de las
index.html | 1 +
1 file changed, 1 insertion(+)
Es algo diferente de la fusión realizada anteriormente con hotfix. En este
caso, el registro de desarrollo había divergido en un punto anterior. Debido a
que la confirmación en la rama actual no es ancestro directo de la rama que
pretendes fusionar, Git tiene cierto trabajo extra que hacer. Git realizará una fu-
sión a tres bandas, utilizando las dos instantáneas apuntadas por el extremo de
cada una de las ramas y por el ancestro común a ambas.
En lugar de simplemente avanzar el apuntador de la rama, Git crea una nue-
va instantánea (snapshot) resultante de la fusión a tres bandas; y crea automá-
ticamente una nueva confirmación de cambios (commit) que apunta a ella. Nos
referimos a este proceso como “fusión confirmada” y su particularidad es que
tiene más de un padre.
Procedimientos Básicos para Ramificar y Fusionar
Git crea
una nueva
conrmación para la
Vale la pena destacar el hecho de que es el propio Git quien determina auto-
máticamente el mejor ancestro común para realizar la fusión; a diferencia de
otros sistemas tales como CVS o Subversion, donde es el desarrollador quien
ha de determinar cuál puede ser dicho mejor ancestro común. Esto hace que en
Git sea mucho más fácil realizar fusiones.
Ahora que todo tu trabajo ya está fusionado con la rama principal, no tienes
necesidad de la rama iss53. Por lo que puedes borrarla y cerrar manualmente
el problema en el sistema de seguimiento de problemas de tu empresa.
$ git branch -d iss53
Principales Conflictos que Pueden Surgir en las Fusiones
En algunas ocasiones, los procesos de fusión no suelen ser fluidos. Si hay modi-
ficaciones dispares en una misma porción de un mismo archivo en las dos
ramas distintas que pretendes fusionar, Git no será capaz de fusionarlas direc-
tamente. Por ejemplo, si en tu trabajo del problema #53 has modificado una
misma porción que también ha sido modificada en el problema hotfix, verás
un conflicto como este:
$ git merge iss53
Auto-merging index.html
CONFLICT (content): Merge conflict in index.html
Automatic merge failed; fix conflicts and then commit the result.
Git no crea automáticamente una nueva fusión confirmada (merge commit),
sino que hace una pausa en el proceso, esperando a que tú resuelvas el conflic-
CHAPTER 3: Ramificaciones en Git
to. Para ver qué archivos permanecen sin fusionar en un determinado momen-
to conflictivo de una fusión, puedes usar el comando git status:
$ git status
On branch master
You have unmerged paths.
(fix conflicts and run "git commit")
Unmerged paths:
(use "git add <file>..." to mark resolution)
both modified: index.html
no changes added to commit (use "git add" and/or "git commit -a")
Todo aquello que sea conflictivo y no se haya podido resolver, se marca co-
mo “sin fusionar” (unmerged). Git añade a los archivos conflictivos unos marca-
dores especiales de resolución de conflictos que te guiarán cuando abras man-
ualmente los archivos implicados y los edites para corregirlos. El archivo con-
flictivo contendrá algo como:
<<<<<<< HEAD:index.html
<div id="footer">contact :</div>
<div id="footer">
please contact us at
>>>>>>> iss53:index.html
Donde nos dice que la versión en HEAD (la rama master, la que habias acti-
vado antes de lanzar el comando de fusión) contiene lo indicado en la parte su-
perior del bloque (todo lo que está encima de =======) y que la versión en
iss53 contiene el resto, lo indicado en la parte inferior del bloque. Para resolv-
er el conflicto, has de elegir manualmente el contenido de uno o de otro lado.
Por ejemplo, puedes optar por cambiar el bloque, dejándolo así:
<div id="footer">
please contact us at
Esta corrección contiene un poco de ambas partes y se han eliminado com-
pletamente las líneas <<<<<<< , ======= y >>>>>>>. Tras resolver todos los
bloques conflictivos, has de lanzar comandos git add para marcar cada archi-
Procedimientos Básicos para Ramificar y Fusionar
vo modificado. Marcar archivos como preparados (staged) indica a Git que sus
conflictos han sido resueltos.
Si en lugar de resolver directamente prefieres utilizar una herramienta gráfi-
ca, puedes usar el comando git mergetool, el cual arrancará la correspon-
diente herramienta de visualización y te permitirá ir resolviendo conflictos con
$ git mergetool
This message is displayed because 'merge.tool' is not configured.
See 'git mergetool --tool-help' or 'git help config' for more details.
'git mergetool' will now attempt to use one of the following tools:
opendiff kdiff3 tkdiff xxdiff meld tortoisemerge gvimdiff diffuse diffmerge ecmerge p4merge araxis bc3 codecompare vimdiff emerge
Normal merge conflict for 'index.html':
{local}: modified file
{remote}: modified file
Hit return to start merge resolution tool (opendiff):
Si deseas usar una herramienta distinta de la escogida por defecto (en mi
caso opendiff, porque estoy lanzando el comando en Mac), puedes escogerla
entre la lista de herramientas soportadas mostradas al principio (“merge tool
candidates”) tecleando el nombre de dicha herramienta.
Si necesitas herramientas más avanzadas para resolver conflictos de fu-
sión más complicados, revisa la sección de fusionado en “Advanced
Tras salir de la herramienta de fusionado, Git preguntará si hemos resuelto
todos los conflictos y la fusión ha sido satisfactoria. Si le indicas que así ha sido,
Git marca como preparado (staged) el archivo que acabamos de modificar. En
cualquier momento, puedes lanzar el comando git status para ver si ya has
resuelto todos los conflictos:
$ git status
On branch master
All conflicts fixed but you are still merging.
(use "git commit" to conclude merge)
Changes to be committed:
CHAPTER 3: Ramificaciones en Git
modified: index.html
Si todo ha ido correctamente, y ves que todos los archivos conflictivos están
marcados como preparados, puedes lanzar el comando git commit para ter-
minar de confirmar la fusión. El mensaje de confirmación por defecto será algo
parecido a:
Merge branch 'iss53'
# It looks like you may be committing a merge.
# If this is not correct, please remove the file
# and try again.
# Please enter the commit message for your changes. Lines starting
# with '#' will be ignored, and an empty message aborts the commit.
# On branch master
# All conflicts fixed but you are still merging.
# Changes to be committed:
# modified: index.html
Puedes modificar este mensaje añadiendo detalles sobre cómo has resuelto
la fusión, si lo consideras útil para que otros entiendan esta fusión en un futuro.
Se trata de indicar por qué has hecho lo que has hecho; a no ser que resulte
obvio, claro está.
Gestión de Ramas
Ahora que ya has creado, fusionado y borrado algunas ramas, vamos a dar un
vistazo a algunas herramientas de gestión muy útiles cuando comienzas a uti-
lizar ramas de manera avanzada.
El comando git branch tiene más funciones que las de crear y borrar
ramas. Si lo lanzas sin parámetros, obtienes una lista de las ramas presentes en
tu proyecto:
Gestión de Ramas
$ git branch
* master
Fijate en el carácter * delante de la rama master: nos indica la rama activa
en este momento (la rama a la que apunta HEAD). Si hacemos una confirmación
de cambios (commit), esa será la rama que avance. Para ver la última confirma-
ción de cambios en cada rama, puedes usar el comando git branch -v:
$ git branch -v
iss53 93b412c fix javascript issue
* master 7a98805 Merge branch 'iss53'
testing 782fd34 add scott to the author list in the readmes
Otra opción útil para averiguar el estado de las ramas, es filtrarlas y mostrar
solo aquellas que han sido fusionadas (o que no lo han sido) con la rama ac-
tualmente activa. Para ello, Git dispone de las opciones --merged y --no-
merged. Si deseas ver las ramas que han sido fusionadas en la rama activa,
puedes lanzar el comando git branch --merged:
$ git branch --merged
* master
Aparece la rama iss53 porque ya ha sido fusionada. Las ramas que no lle-
van por delante el caracter * pueden ser eliminadas sin problemas, porque to-
do su contenido ya ha sido incorporado a otras ramas.
Para mostrar todas las ramas que contienen trabajos sin fusionar, puedes
utilizar el comando git branch --no-merged:
$ git branch --no-merged
Esto nos muestra la otra rama del proyecto. Debido a que contiene trabajos
sin fusionar, al intentarla borrarla con git branch -d, el comando nos dará
un error:
CHAPTER 3: Ramificaciones en Git
$ git branch -d testing
error: The branch 'testing' is not fully merged.
If you are sure you want to delete it, run 'git branch -D testing'.
Si realmente deseas borrar la rama, y perder el trabajo contenido en ella,
puedes forzar el borrado con la opción -D; tal y como indica el mensaje de ayu-
Flujos de Trabajo Ramificados
Ahora que ya has visto los procedimientos básicos de ramificación y fusión,
¿qué puedes o qué debes hacer con ellos? En este apartado vamos a ver algu-
nos de los flujos de trabajo más comunes, de tal forma que puedas decidir si te
gustaría incorporar alguno de ellos a tu ciclo de desarrollo.
Ramas de Largo Recorrido
Por la sencillez de la fusión a tres bandas de Git, el fusionar una rama a otra
varias veces a lo largo del tiempo es fácil de hacer. Esto te posibilita tener varias
ramas siempre abiertas, e irlas usando en diferentes etapas del ciclo de desar-
rollo; realizando fusiones frecuentes entre ellas.
Muchos desarrolladores que usan Git llevan un flujo de trabajo de esta natu-
raleza, manteniendo en la rama master únicamente el código totalmente esta-
ble (el código que ha sido o que va a ser liberado) y teniendo otras ramas paral-
elas denominadas desarrollo o siguiente, en las que trabajan y realizan
pruebas. Estas ramas paralelas no suele estar siempre en un estado estable;
pero cada vez que sí lo están, pueden ser fusionadas con la rama master. Tam-
bién es habitual el incorporarle (pull) ramas puntuales (ramas temporales, co-
mo la rama iss53 del ejemplo anterior) cuando las completamos y estamos se-
guros de que no van a introducir errores.
En realidad, en todo momento estamos hablando simplemente de apunta-
dores moviéndose por la línea temporal de confirmaciones de cambio (commit
history). Las ramas estables apuntan hacia posiciones más antiguas en el his-
torial de confirmaciones, mientras que las ramas avanzadas, las que van
abriendo camino, apuntan hacia posiciones más recientes.
Flujos de Trabajo Ramificados
Una vista lineal del
progresivo estable
Una vista tipo “silo”
del ramicado
progresivo estable
Podría ser más sencillo pensar en las ramas como si fueran silos de almace-
namiento, donde grupos de confirmaciones de cambio (commits) van siendo
promocionados hacia silos más estables a medida que son probados y depura-
Este sistema de trabajo se puede ampliar para diversos grados de estabili-
dad. Algunos proyectos muy grandes suelen tener una rama denominada pro-
puestas o pu (del inglés “proposed updates, propuesta de actualización),
donde suele estar todo aquello integrado desde otras ramas, pero que aún no
está listo para ser incorporado a las ramas siguiente o master. La idea es
mantener siempre diversas ramas en diversos grados de estabilidad; pero
cuando alguna alcanza un estado más estable, la fusionamos con la rama in-
mediatamente superior a ella. Aunque no es obligatorio el trabajar con ramas
de larga duración, realmente es práctico y útil, sobre todo en proyectos largos o
Ramas Puntuales
Las ramas puntuales, en cambio, son útiles en proyectos de cualquier tamaño.
Una rama puntual es aquella rama de corta duración que abres para un tema o
para una funcionalidad determinada. Es algo que nunca habrías hecho en otro
sistema VCS, debido a los altos costos de crear y fusionar ramas en esos siste-
CHAPTER 3: Ramificaciones en Git
Múltiples ramas
mas. Pero en Git, por el contrario, es muy habitual el crear, trabajar con, fusio-
nar y eliminar ramas varias veces al día.
Tal y como has visto con las ramas iss53 y hotfix que has creado en la sec-
ción anterior. Has hecho algunas confirmaciones de cambio en ellas, y luego las
has borrado tras fusionarlas con la rama principal. Esta técnica te posibilita re-
alizar cambios de contexto rápidos y completos y, debido a que el trabajo está
claramente separado en silos, con todos los cambios de cada tema en su propia
rama, te será mucho más sencillo revisar el código y seguir su evolución.
Puedes mantener los cambios ahí durante minutos, dias o meses; y fusionarlos
cuando realmente estén listos, sin importar el orden en el que fueron creados o
en el que comenzaste a trabajar en ellos.
Por ejemplo, puedes realizar cierto trabajo en la rama master, ramificar
para un problema concreto (rama iss91), trabajar en él un rato, ramificar una
segunda vez para probar otra manera de resolverlo (rama iss92v2), volver a la
rama master y trabajar un poco más, y, por último, ramificar temporalmente
para probar algo de lo que no estás seguro (rama dumbidea). El historial de
confirmaciones (commit history) será algo parecido esto:
Flujos de Trabajo Ramificados
El historial tras
fusionar dumbidea e
En este momento, supongamos que te decides por la segunda solución al
problema (rama iss92v2); y que, tras mostrar la rama dumbidea a tus compa-
ñeros, resulta que les parece una idea genial. Puedes descartar la rama iss91
(perdiendo las confirmaciones C5 y C6), y fusionar las otras dos. El historial será
algo parecido a esto:
Hablaremos un poco más sobre los distintos flujos de trabajo de tu proyecto
Git en Chapter 5, así que antes de decidir qué estilo de ramificación usará tu
próximo proyecto, asegúrate de haber leído ese capítulo.
Es importante recordar que, mientras estás haciendo todo esto, todas las
ramas son completamente locales. Cuando ramificas y fusionas, todo se realiza
CHAPTER 3: Ramificaciones en Git
en tu propio repositorio Git. No hay nigún tipo de comunicación con ningún ser-
Ramas Remotas
Las ramas remotas son referencias al estado de las ramas en tus repositorios
remotos. Son ramas locales que no puedes mover; se mueven automática-
mente cuando estableces comunicaciones en la red. Las ramas remotas fun-
cionan como marcadores, para recordarte en qué estado se encontraban tus re-
positorios remotos la última vez que conectaste con ellos.
Suelen referenciarse como (remoto)/(rama). Por ejemplo, si quieres saber
cómo estaba la rama master en el remoto origin, puedes revisar la rama
origin/master. O si estás trabajando en un problema con un compañero y
este envía (push) una rama iss53, tú tendrás tu propia rama de trabajo local
iss53; pero la rama en el servidor apuntará a la última confirmación (commit)
en la rama origin/iss53.
Esto puede ser un tanto confuso, pero intentemos aclararlo con un ejemplo.
Supongamos que tienes un sevidor Git en tu red, en Si
haces un clón desde ahí, Git automáticamente lo denominará origin, traerá
(pull) sus datos, creará un apuntador hacia donde esté en ese momento su
rama master y denominará la copia local origin/master. Git te proporcio-
nará también tu propia rama master, apuntando al mismo lugar que la rama
master de origin; de manera que tengas donde trabajar.
Así como la rama “master” no tiene ningún significado especial en Git,
tampoco lo tiene “origin”. “master” es un nombre muy usado solo por-
que es el nombre por defecto que Git le da a la rama inicial cuando ejecu-
tas git init. De la misma manera, “origin” es el nombre por defecto que
Git le da a un remoto cuando ejecutas git clone. Si en cambio ejecutases
git clone -o booyah, tendrías una rama booyah/master como rama remo-
ta por defecto.
Ramas Remotas
Servidor y
repositorio local
luego de ser clonado
Si haces algún trabajo en tu rama master local, y al mismo tiempo, alguien
más lleva (push) su trabajo al servidor, actualizando la
rama master de allí, te encontrarás con que ambos registros avanzan de forma
diferente. Además, mientras no tengas contacto con el servidor, tu apuntador a
tu rama origin/master no se moverá.
CHAPTER 3: Ramificaciones en Git
El trabajo remoto y
el local pueden
Para sincronizarte, puedes utilizar el comando git fetch origin. Este co-
mando localiza en qué servidor está el origen (en este caso git.ourcompa-, recupera cualquier dato presente allí que tú no tengas, y actualiza tu
base de datos local, moviendo tu rama origin/master para que apunte a la
posición más reciente.
Ramas Remotas
git fetch actualiza
las referencias de tu
Para ilustrar mejor el caso de tener múltiples servidores y cómo van las
ramas remotas para esos proyectos remotos, supongamos que tienes otro ser-
vidor Git; utilizado por uno de tus equipos sprint, solamente para desarrollo.
Este servidor se encuentra en Puedes incluirlo
como una nueva referencia remota a tu proyecto actual, mediante el comando
git remote add, tal y como vimos en Chapter 2. Puedes denominar teamone
a este remoto al asignarle este nombre a la URL.
CHAPTER 3: Ramificaciones en Git
Añadiendo otro
servidor como
Ahora, puedes usar el comando git fetch teamone para recuperar todo
el contenido del remoto teamone que tú no tenias. Debido a que dicho servidor
es un subconjunto de los datos del servidor origin que tienes actualmente, Git
no recupera (fetch) ningún dato; simplemente prepara una rama remota llama-
da teamone/master para apuntar a la confirmación (commit) que teamone
tiene en su rama master.
Ramas Remotas
Seguimiento de la
rama remota a
través de teamone/
Cuando quieres compartir una rama con el resto del mundo, debes llevarla
(push) a un remoto donde tengas permisos de escritura. Tus ramas locales no
se sincronizan automáticamente con los remotos en los que escribes, sino que
tienes que enviar (push) expresamente las ramas que desees compartir. De esta
forma, puedes usar ramas privadas para el trabajo que no deseas compartir, lle-
vando a un remoto tan solo aquellas partes que deseas aportar a los demás.
Si tienes una rama llamada serverfix, con la que vas a trabajar en colabor-
ación; puedes llevarla al remoto de la misma forma que llevaste tu primera
rama. Con el comando git push (remoto) (rama):
$ git push origin serverfix
Counting objects: 24, done.
Delta compression using up to 8 threads.
Compressing objects: 100% (15/15), done.
Writing objects: 100% (24/24), 1.91 KiB | 0 bytes/s, done.
Total 24 (delta 2), reused 0 (delta 0)
* [new branch] serverfix -> serverfix
CHAPTER 3: Ramificaciones en Git
Esto es un atajo. Git expande automáticamente el nombre de rama server-
fix a refs/heads/serverfix:refs/heads/serverfix, que significa: “coge
mi rama local serverfix y actualiza con ella la rama serverfix del remoto”.
Volveremos más tarde sobre el tema de refs/heads/, viéndolo en detalle en
Chapter 10; por ahora, puedes ignorarlo. También puedes hacer git push
origin serverfix:serverfix, que hace lo mismo; es decir: “coge mi serv-
erfix y hazlo el serverfix remoto. Puedes utilizar este último formato para
llevar una rama local a una rama remota con un nombre distinto. Si no quieres
que se llame serverfix en el remoto, puedes lanzar, por ejemplo, git push
origin serverfix:awesomebranch; para llevar tu rama serverfix local a
la rama awesomebranch en el proyecto remoto.
Si utilizas una dirección URL con HTTPS para enviar datos, el servidor Git
te preguntará tu usuario y contraseña para autenticarte. Por defecto, te
pedirá esta información a través del terminal, para determinar si estás
autorizado a enviar datos.
Si no quieres escribir tu contraseña cada vez que haces un envío, puedes
establecer un “cache de credenciales”. La manera más sencilla de hacerlo
es estableciéndolo en memoria por unos minutos, lo que puedes lograr
fácilmente al ejecutar git config --global credential.helper cache
Para más información sobre las distintas opciones de cache de creden-
ciales, véase “Credential Storage”.
La próxima vez que tus colaboradores recuperen desde el servidor, obten-
drán bajo la rama remota origin/serverfix una referencia a donde esté la
versión de serverfix en el servidor:
$ git fetch origin
remote: Counting objects: 7, done.
remote: Compressing objects: 100% (2/2), done.
remote: Total 3 (delta 0), reused 3 (delta 0)
Unpacking objects: 100% (3/3), done.
* [new branch] serverfix -> origin/serverfix
Es importante destacar que cuando recuperas (fetch) nuevas ramas remo-
tas, no obtienes automáticamente una copia local editable de las mismas. En
otras palabras, en este caso, no tienes una nueva rama serverfix. Sino que
únicamente tienes un puntero no editable a origin/serverfix.
Ramas Remotas
Para integrar (merge) esto en tu rama de trabajo actual, puedes usar el co-
mando git merge origin/serverfix. Y si quieres tener tu propia rama
serverfix para trabajar, puedes crearla directamente basandote en la rama
$ git checkout -b serverfix origin/serverfix
Branch serverfix set up to track remote branch serverfix from origin.
Switched to a new branch 'serverfix'
Esto sí te da una rama local donde puedes trabajar, que comienza donde
origin/serverfix estaba en ese momento.
Hacer Seguimiento a las Ramas
Al activar (checkout) una rama local a partir de una rama remota, se crea auto-
máticamente lo que podríamos denominar una “rama de seguimiento” (track-
ing branch). Las ramas de seguimiento son ramas locales que tienen una rela-
ción directa con alguna rama remota. Si estás en una rama de seguimiento y
tecleas el comando git pull, Git sabe de cuál servidor recuperar (fetch) y fu-
sionar (merge) datos.
Cuando clonas un repositorio, este suele crear automáticamente una rama
master que hace seguimiento de origin/master. Sin embargo, puedes pre-
parar otras ramas de seguimiento si deseas tener unas que sigan ramas de
otros remotos o no seguir la rama master. El ejemplo más simple es el que aca-
bas de ver al lanzar el comando git checkout -b [rama] [nombreremo-
to]/[rama]. Esta operación es tan común que git ofrece el parámetro --
$ git checkout --track origin/serverfix
Branch serverfix set up to track remote branch serverfix from origin.
Switched to a new branch 'serverfix'
Para preparar una rama local con un nombre distinto a la del remoto,
puedes utilizar la primera versión con un nombre de rama local diferente:
$ git checkout -b sf origin/serverfix
Branch sf set up to track remote branch serverfix from origin.
Switched to a new branch 'sf'
CHAPTER 3: Ramificaciones en Git
Así, tu rama local sf traerá (pull) información automáticamente desde ori-
Si ya tienes una rama local y quieres asignarla a una rama remota que aca-
bas de traerte, o quieres cambiar la rama a la que le haces seguimiento, puedes
usar en cualquier momento las opciones -u o --set-upstream-to del coman-
do git branch.
$ git branch -u origin/serverfix
Branch serverfix set up to track remote branch serverfix from origin.
Cuando tienes asignada una rama de seguimiento, puedes hacer referen-
cia a ella mediante @{upstream} o mediante el atajo @{u}. De esta manera,
si estás en la rama master y esta sigue a la rama origin/master, puedes
hacer algo como git merge @{u} en vez de git merge origin/master.
Si quieres ver las ramas de seguimiento que tienes asignado, puedes usar la
opción -vv con git branch. Esto listará tus ramas locales con más informa-
ción, incluyendo a qué sigue cada rama y si tu rama local está por delante, por
detrás o ambas.
$ git branch -vv
iss53 7e424c3 [origin/iss53: ahead 2] forgot the brackets
master 1ae2a45 [origin/master] deploying index fix
* serverfix f8674d9 [teamone/server-fix-good: ahead 3, behind 1] this should do it
testing 5ea463a trying something new
Aquí podemos ver que nuestra rama iss53 sigue origin/iss53 y está
ahead” (delante) por dos, es decir, que tenemos dos confirmaciones locales
que no han sido enviadas al servidor. También podemos ver que nuestra rama
master sigue a origin/master y está actualizada. Luego podemos ver que
nuestra rama serverfix sigue la rama server-fix-good de nuestro servidor
teamone y que está tres cambios por delante (ahead) y uno por detrás (behind),
lo que significa que existe una confirmación en el servidor que no hemos fusio-
nado y que tenemos tres confirmaciones locales que no hemos enviado. Por úl-
timo, podemos ver que nuestra rama testing no sigue a ninguna rama remo-
Es importante destacar que estos números se refieren a la última vez que
trajiste (fetch) datos de cada servidor. Este comando no se comunica con los
servidores, solo te indica lo que sabe de ellos localmente. Si quieres tener los
Ramas Remotas
cambios por delante y por detrás actualizados, debes traertelos (fetch) de cada
servidor antes de ejecutar el comando. Puedes hacerlo de esta manera: $ git
fetch --all; git branch -vv
Traer y Fusionar
A pesar de que el comando git fetch trae todos los cambios del servidor que
no tienes, este no modifica tu directorio de trabajo. Simplemente obtendrá los
datos y dejará que tú mismo los fusiones. Sin embargo, existe un comando lla-
mado git pull, el cuál básicamente hace git fetch seguido por git merge
en la mayoría de los casos. Si tienes una rama de seguimiento configurada co-
mo vimos en la última sección, bien sea asignándola explícitamente o creándo-
la mediante los comandos clone o checkout, git pull identificará a qué ser-
vidor y rama remota sigue tu rama actual, traerá los datos de dicho servidor e
intentará fusionar dicha rama remota.
Normalmente es mejor usar los comandos fetch y merge de manera explíc-
ita pues la magia de git pull puede resultar confusa.
Eliminar Ramas Remotas
Imagina que ya has terminado con una rama remota, es decir, tanto tú como
tus colaboradores habéis completado una determinada funcionalidad y la ha-
béis incorporado (merge) a la rama master en el remoto (o donde quiera que
tengáis la rama de código estable). Puedes borrar la rama remota utilizando la
opción --delete de git push. Por ejemplo, si quieres borrar la rama server-
fix del servidor, puedes utilizar:
$ git push origin --delete serverfix
- [deleted] serverfix
Básicamente lo que hace es eliminar el apuntador del servidor. El servidor
Git suele mantener los datos por un tiempo hasta que el recolector de basura se
ejecute, de manera que si la has borrado accidentalmente, suele ser fácil recu-
CHAPTER 3: Ramificaciones en Git
El registro de
Reorganizar el Trabajo Realizado
En Git tenemos dos formas de integrar cambios de una rama en otra: la fusión
(merge) y la reorganización (rebase). En esta sección vas a aprender en qué con-
siste la reorganización, cómo utilizarla, por qué es una herramienta sorpren-
dente y en qué casos no es conveniente utilizarla.
Reorganización Básica
Volviendo al ejemplo anterior, en la sección sobre fusiones “Procedimientos
Básicos de Fusión” puedes ver que has separado tu trabajo y realizado confir-
maciones (commit) en dos ramas diferentes.
La manera más sencilla de integrar ramas, tal y como hemos visto, es el co-
mando git merge. Realiza una fusión a tres bandas entre las dos últimas in-
stantáneas de cada rama (C3 y C4) y el ancestro común a ambas (C2); creando
una nueva instantánea (snapshot) y la correspondiente confirmación (commit).
Reorganizar el Trabajo Realizado
Fusionar una rama
para integrar el
registro de trabajos
sobre C3 los cambios
introducidos en C4
Sin embargo, también hay otra forma de hacerlo: puedes coger los cambios
introducidos en C3 y reaplicarlos encima de C4. Esto es lo que en Git llamamos
reorganizar (rebasing, en inglés). Con el comando git rebase, puedes coger
todos los cambios confirmados en una rama, y reaplicarlos sobre otra.
Por ejemplo, puedes lanzar los comandos:
$ git checkout experiment
$ git rebase master
First, rewinding head to replay your work on top of it...
Applying: added staged command
Haciendo que Git vaya al ancestro común de ambas ramas (donde estás ac-
tualmente y de donde quieres reorganizar), saque las diferencias introducidas
por cada confirmación en la rama donde estás, guarde esas diferencias en ar-
chivos temporales, reinicie (reset) la rama actual hasta llevarla a la misma con-
firmación en la rama de donde quieres reorganizar, y, finalmente, vuelva a apli-
car ordenadamente los cambios.
CHAPTER 3: Ramificaciones en Git
Avance rápido de la
rama master
En este momento, puedes volver a la rama master y hacer una fusión con
avance rápido (fast-forward merge).
$ git checkout master
$ git merge experiment
Así, la instantánea apuntada por C4' es exactamente la misma apuntada
por C5 en el ejemplo de la fusión. No hay ninguna diferencia en el resultado fi-
nal de la integración, pero el haberla hecho reorganizando nos deja un historial
más claro. Si examinas el historial de una rama reorganizada, este aparece
siempre como un historial lineal: como si todo el trabajo se hubiera realizado
en series, aunque realmente se haya hecho en paralelo.
Habitualmente, optarás por esta vía cuando quieras estar seguro de que tus
confirmaciones de cambio (commits) se pueden aplicar limpiamente sobre una
rama remota; posiblemente, en un proyecto donde estés intentando colaborar,
pero lleves tú el mantenimiento. En casos como esos, puedes trabajar sobre
una rama y luego reorganizar lo realizado en la rama origin/master cuando
lo tengas todo listo para enviarlo al proyecto principal. De esta forma, la per-
sona que mantiene el proyecto no necesitará hacer ninguna integración con tu
trabajo; le bastará con un avance rápido o una incorporación limpia.
Cabe destacar que la instantánea (snapshot) apuntada por la confirmación
(commit) final, tanto si es producto de una reorganización (rebase) como si lo
es de una fusión (merge), es exactamente la misma instantánea; lo único difer-
ente es el historial. La reorganización vuelve a aplicar cambios de una rama de
trabajo sobre otra rama, en el mismo orden en que fueron introducidos en la
primera, mientras que la fusión combina entre sí los dos puntos finales de am-
bas ramas.
Reorganizar el Trabajo Realizado
Un historial con una
rama puntual sobre
otra rama puntual
Algunas Reorganizaciones Interesantes
También puedes aplicar una reorganización (rebase) sobre otra cosa además
de sobre la rama de reorganización. Por ejemplo, considera un historial como el
de Figure 3-31. Has ramificado a una rama puntual (server) para añadir algu-
nas funcionalidades al proyecto, y luego has confirmado los cambios. Después,
vuelves a la rama original para hacer algunos cambios en la parte cliente (rama
client), y confirmas también esos cambios. Por último, vuelves sobre la rama
server y haces algunos cambios más.
Imagina que decides incorporar tus cambios del lado cliente sobre el
proyecto principal para hacer un lanzamiento de versión; pero no quieres lan-
zar aún los cambios del lado servidor porque no están aún suficientemente
probados. Puedes coger los cambios del cliente que no están en server (C8 y
C9) y reaplicarlos sobre tu rama principal usando la opción --onto del coman-
do git rebase:
$ git rebase --onto master server client
Esto viene a decir: “Activa la rama client, averigua los cambios desde el
ancestro común entre las ramas client y server, y aplicalos en la rama mas-
ter. Puede parecer un poco complicado, pero los resultados son realmente in-
CHAPTER 3: Ramificaciones en Git
Reorganizando una
rama puntual fuera
de otra rama
Avance rápido de tu
rama master, para
incluir los cambios
de la rama client
Y, tras esto, ya puedes avanzar la rama principal (ver Figure 3-33):
$ git checkout master
$ git merge client
Ahora supongamos que decides traerlos (pull) también sobre tu rama serv-
er. Puedes reorganizar (rebase) la rama server sobre la rama master sin nec-
esidad siquiera de comprobarlo previamente, usando el comando git rebase
[rama-base] [rama-puntual], el cual activa la rama puntual (server en
este caso) y la aplica sobre la rama base (master en este caso):
$ git rebase master server
Esto vuelca el trabajo de server sobre el de master, tal y como se muestra
en Figure 3-34.
Reorganizar el Trabajo Realizado
Reorganizando la
rama server sobre
la rama master
Historial nal de
conrmaciones de
Después, puedes avanzar rápidamente la rama base (master):
$ git checkout master
$ git merge server
Y por último puedes eliminar las ramas client y server porque ya todo su
contenido ha sido integrado y no las vas a necesitar más, dejando tu registro
tras todo este proceso tal y como se muestra en Figure 3-35:
$ git branch -d client
$ git branch -d server
Los Peligros de Reorganizar
Ahh…, pero la dicha de la reorganización no la alcanzamos sin sus contraparti-
das, las cuales pueden resumirse en una línea:
Nunca reorganices confirmaciones de cambio (commits) que hayas en-
viado (push) a un repositorio público.
Si sigues esta recomendación, no tendrás problemas. Pero si no lo haces, la
gente te odiará y serás despreciado por tus familiares y amigos.
Cuando reorganizas algo, estás abandonando las confirmaciones de cambio
ya creadas y estás creando unas nuevas; que son similares, pero diferentes. Si
envias (push) confirmaciones (commits) a alguna parte, y otros las recogen
(pull) de allí; y después vas tú y las reescribes con git rebase y las vuelves a
enviar (push); tus colaboradores tendrán que refusionar (re-merge) su trabajo y
CHAPTER 3: Ramificaciones en Git
Clonar un
repositorio y
trabajar sobre él
todo se volverá tremendamente complicado cuando intentes recoger (pull) su
trabajo de vuelta sobre el tuyo.
Veamos con un ejemplo como reorganizar trabajo que has hecho público
puede causar problemas. Imagínate que haces un clon desde un servidor cen-
tral, y luego trabajas sobre él. Tu historial de cambios puede ser algo como es-
Ahora, otra persona trabaja también sobre ello, realiza una fusión (merge) y
lleva (push) su trabajo al servidor central. Tú te traes (fetch) sus trabajos y los
fusionas (merge) sobre una nueva rama en tu trabajo, con lo que tu historial
quedaría parecido a esto:
Reorganizar el Trabajo Realizado
Traer (fetch)
conrmaciones de
cambio (commits) y
fusionarlas (merge)
sobre tu trabajo
Alguien envií (push)
abandonando las
conrmaciones en
las que tu habías
basado tu trabajo
A continuación, la persona que había llevado cambios al servidor central de-
cide retroceder y reorganizar su trabajo; haciendo un git push --force para
sobrescribir el registro en el servidor. Tu te traes (fetch) esos nuevos cambios
desde el servidor.
CHAPTER 3: Ramificaciones en Git
Vuelves a fusionar el
mismo trabajo en
una nueva fusión
Ahora los dos están en un aprieto. Si haces git pull crearás una fusión
confirmada, la cual incluirá ambas líneas del historial, y tu repositorio lucirá así:
Si ejecutas git log sobre un historial así, verás dos confirmaciones hechas
por el mismo autor y con la misma fecha y mensaje, lo cual será confuso. Es
más, si luego tu envías (push) ese registro de vuelta al servidor, vas a introducir
todas esas confirmaciones reorganizadas en el servidor central. Lo que puede
confundir aún más a la gente. Era más seguro asumir que el otro desarrollador
no quería que C4 y C6 estuviesen en el historial; por ello había reorganizado su
trabajo de esa manera.
Reorganizar una Reorganización
Si te encuentras en una situación como esta, Git tiene algunos trucos que pue-
den ayudarte. Si alguien de tu equipo sobreescribe cambios en los que se basa-
ba tu trabajo, tu reto es descubrir qué han sobreescrito y qué te pertenece.
Además de la suma de control SHA-1, Git calcula una suma de control basa-
da en el parche que introduce una confirmación. A esta se le conoce como
Si te traes el trabajo que ha sido sobreescrito y lo reorganizas sobre las nue-
vas confirmaciones de tu compañero, es posible que Git pueda identificar qué
parte correspondía específicamente a tu trabajo y aplicarla de vuelta en la
rama nueva.
Reorganizar el Trabajo Realizado
Reorganizar encima
de un trabajo
Por ejemplo, en el caso anterior, si en vez de hacer una fusión cuando está-
bamos en Figure 3-38 ejecutamos git rebase teamone/master, Git hará lo
Determinar el trabajo que es específico de nuestra rama (C2, C3, C4, C6,
Determinar cuáles no son fusiones confirmadas (C2, C3, C4)
Determinar cuáles no han sido sobreescritas en la rama destino (solo C2 y
C3, pues C4 corresponde al mismo parche que C4')
Aplicar dichas confirmaciones encima de teamone/master
Así que en vez del resultado que vimos en Figure 3-39, terminaremos con
algo más parecido a Figure 3-40.
Esto solo funciona si C4 y el C4’ de tu compañero son parches muy similares.
De lo contrario, la reorganización no será capaz de identificar que se trata de un
duplicado y agregará otro parche similar a C4 (lo cual probablemente no podrá
aplicarse limpiamente, pues los cambios ya estarían allí en algún lugar).
También puedes simplificar el proceso si ejecutas git pull --rebase en
vez del tradicional git pull. O, en este caso, puedes hacerlo manualmente
con un git fetch primero, seguido de un git rebase teamone/master.
Si sueles utilizar git pull y quieres que la opción --rebase esté activada
por defecto, puedes asignar el valor de configuración pull.rebase haciendo
algo como esto git config --global pull.rebase true.
CHAPTER 3: Ramificaciones en Git
Si consideras la reorganización como una manera de limpiar tu trabajo y tus
confirmaciones antes de enviarlas (push), y si solo reorganizas confirmaciones
(commits) que nunca han estado disponibles públicamente, no tendrás prob-
lemas. Si reorganizas (rebase) confirmaciones (commits) que ya estaban dis-
ponibles públicamente y la gente había basado su trabajo en ellas, entonces
prepárate para tener problemas, frustar a tu equipo y ser despreciado por tus
Si tu compañero o tú ven que aun así es necesario hacerlo en algún momen-
to, asegúrense que todos sepan que deben ejecutar git pull --rebase para
intentar aliviar en lo posible la frustración.
Reorganizar vs. Fusionar
Ahora que has visto en acción la reorganización y la fusión, te preguntarás cuál
es mejor. Antes de responder, repasemos un poco qué representa el historial.
Para algunos, el historial de confirmaciones de tu repositorio es un registro
de todo lo que ha pasado. Un documento histórico, valioso por sí mismo y que
no debería ser alterado. Desde este punto de vista, cambiar el historial de con-
firmaciones es casi como blasfemar; estarías mintiendo sobre lo que en verdad
ocurrió. ¿Y qué pasa si hay una serie desastrosa de fusiones confirmadas? Nada.
Así fue como ocurrió y el repositorio debería tener un registro de esto para la
La otra forma de verlo es que el historial de confirmaciones es la historia de
cómo se hizo tu proyecto. Tú no publicarías el primer borrador de tu novela, y
el manual de cómo mantener tus programas también debe estar editado con
mucho cuidado. Esta es el área que utiliza herramientas como rebase y
filter-branch para contar la historia de la mejor manera para los futuros lec-
Ahora, sobre qué es mejor si fusionar o reorganizar: verás que la respuesta
no es tan sencilla. Git es una herramienta poderosa que te permite hacer mu-
chas cosas con tu historial, y cada equipo y cada proyecto es diferente. Ahora
que conoces cómo trabajan ambas herramientas, será cosa tuya decidir cuál de
las dos es mejor para tu situación en particular.
Normalmente, la manera de sacar lo mejor de ambas es reorganizar tu tra-
bajo local, que aun no has compartido, antes de enviarlo a algún lugar; pero
nunca reorganizar nada que ya haya sido compartido.
Hemos visto los procedimientos básicos de ramificación (branching) y fusión
(merging) en Git. A estas alturas, te sentirás cómodo creando nuevas ramas
(branch), saltando (checkout) entre ramas para trabajar y fusionando (merge)
ramas entre ellas. También conocerás cómo compartir tus ramas enviándolas
(push) a un servidor compartido, cómo trabajar colaborativamente en ramas
compartidas, y cómo reorganizar (rebase) tus ramas antes de compartirlas. A
continuación, hablaremos sobre lo que necesitas para tener tu propio servidor
de hospedaje Git.
CHAPTER 3: Ramificaciones en Git
Git en el Servidor
En este punto, deberías ser capaz de realizar la mayoría de las tareas diarias
para las cuales estarás usando Git. Sin embargo, para poder realizar cualquier
colaboración en Git, necesitarás tener un repositorio remoto Git. Aunque técni-
camente puedes enviar y recibir cambios desde repositorios de otros individ-
uos, no se recomienda hacerlo porque, si no tienes cuidado, fácilmente podrías
confudir en que es en lo que se está trabajando. Además, lo deseable es que tus
colaboradores sean capaces de acceder al repositorio incluso si tu computa-
dora no está en línea – muchas veces es útil tener un repositorio confiable en
común. Por lo tanto, el método preferido para colaborar con otra persona es
configurar un repositorio intermedio al cual ambos tengan acceso, y enviar
(push) y recibir (pull) desde allí.
Poner en funcionamiento un servidor Git es un proceso bastante claro. Pri-
mero, eliges con qué protocolos ha de comunicarse tu servidor. La primera sec-
ción de este capítulo cubrirá los protocolos disponibles, así como los pros y los
contras de cada uno. Las siguientes secciones explicarán algunas configura-
ciones comunes utilizando dichos protocolos y como poner a funcionar tu ser-
vidor con alguno de ellos. Finalmente, revisaremos algunas de las opciones
hospedadas, si no te importa hospedar tu código en el servidor de alguien más
y no quieres tomarte la molestia de configurar y mantener tu propio servidor.
Si no tienes interés en tener tu propio servidor, puedes saltarte hasta la últi-
ma sección de este capítulo para ver algunas de las opciones para configurar
una cuenta hospedada y seguir al siguiente capítulo, donde discutiremos los
varios pormenores de trabajar en un ambiente de control de fuente distribuído.
Un repositorio remoto es generalmente un repositorio básico – un repositor-
io Git que no tiene directorio de trabajo. Dado que el repositorio es solamente
utilizado como un punto de colaboración, no hay razín para tener una copia in-
stantánea verificada en el disco; tan solo son datos Git. En los más simples tér-
minos, un repositorio básico es el contenido .git del directorio de tu proyecto
y nada más.
The Protocols
Git can use four major protocols to transfer data: Local, HTTP, Secure Shell
(SSH) and Git. Here we’ll discuss what they are and in what basic circumstances
you would want (or not want) to use them.
Local Protocol
The most basic is the Local protocol, in which the remote repository is in anoth-
er directory on disk. This is oen used if everyone on your team has access to a
shared filesystem such as an NFS mount, or in the less likely case that everyone
logs in to the same computer. The latter wouldn’t be ideal, because all your
code repository instances would reside on the same computer, making a cata-
strophic loss much more likely.
If you have a shared mounted filesystem, then you can clone, push to, and
pull from a local file-based repository. To clone a repository like this or to add
one as a remote to an existing project, use the path to the repository as the
URL. For example, to clone a local repository, you can run something like this:
$ git clone /opt/git/project.git
Or you can do this:
$ git clone file:///opt/git/project.git
Git operates slightly dierently if you explicitly specify file:// at the begin-
ning of the URL. If you just specify the path, Git tries to use hardlinks or directly
copy the files it needs. If you specify file://, Git fires up the processes that it
normally uses to transfer data over a network which is generally a lot less ei-
cient method of transferring the data. The main reason to specify the file://
prefix is if you want a clean copy of the repository with extraneous references or
objects le out – generally aer an import from another version-control system
or something similar (see Chapter 10 for maintenance tasks). We’ll use the nor-
mal path here because doing so is almost always faster.
To add a local repository to an existing Git project, you can run something
like this:
$ git remote add local_proj /opt/git/project.git
CHAPTER 4: Git en el Servidor
Then, you can push to and pull from that remote as though you were doing
so over a network.
The pros of file-based repositories are that they’re simple and they use existing
file permissions and network access. If you already have a shared filesystem to
which your whole team has access, setting up a repository is very easy. You
stick the bare repository copy somewhere everyone has shared access to and
set the read/write permissions as you would for any other shared directory.
We’ll discuss how to export a bare repository copy for this purpose in “Configu-
rando Git en un servidor”.
This is also a nice option for quickly grabbing work from someone else’s
working repository. If you and a co-worker are working on the same project and
they want you to check something out, running a command like git pull /
home/john/project is oen easier than them pushing to a remote server and
you pulling down.
The cons of this method are that shared access is generally more diicult to set
up and reach from multiple locations than basic network access. If you want to
push from your laptop when you’re at home, you have to mount the remote
disk, which can be diicult and slow compared to network-based access.
It’s also important to mention that this isn’t necessarily the fastest option if
you’re using a shared mount of some kind. A local repository is fast only if you
have fast access to the data. A repository on NFS is oen slower than the reposi-
tory over SSH on the same server, allowing Git to run o local disks on each sys-
The HTTP Protocols
Git can communicate over HTTP in two dierent modes. Prior to Git 1.6.6 there
was only one way it could do this which was very simple and generally read-
only. In version 1.6.6 a new, smarter protocol was introduced that involved Git
being able to intelligently negotiate data transfer in a manner similar to how it
does over SSH. In the last few years, this new HTTP protocol has become very
popular since it’s simpler for the user and smarter about how it communicates.
The newer version is oen referred to as the “Smart” HTTP protocol and the
older way as “Dumb” HTTP. We’ll cover the newer “smart” HTTP protocol first.
The Protocols
The “smart” HTTP protocol operates very similarly to the SSH or Git protocols
but runs over standard HTTP/S ports and can use various HTTP authentication
mechanisms, meaning it’s oen easier on the user than something like SSH,
since you can use things like username/password basic authentication rather
than having to set up SSH keys.
It has probably become the most popular way to use Git now, since it can be
set up to both serve anonymously like the git:// protocol, and can also be
pushed over with authentication and encryption like the SSH protocol. Instead
of having to set up dierent URLs for these things, you can now use a single URL
for both. If you try to push and the repository requires authentication (which it
normally should), the server can prompt for a username and password. The
same goes for read access.
In fact, for services like GitHub, the URL you use to view the repository online
(for example, “”) is the same URL you
can use to clone and, if you have access, push over.
If the server does not respond with a Git HTTP smart service, the Git client will
try to fall back to the simpler “dumb” HTTP protocol. The Dumb protocol ex-
pects the bare Git repository to be served like normal files from the web server.
The beauty of the Dumb HTTP protocol is the simplicity of setting it up. Basical-
ly, all you have to do is put a bare Git repository under your HTTP document
root and set up a specific post-update hook, and you’re done (See “Git
Hooks”). At that point, anyone who can access the web server under which you
put the repository can also clone your repository. To allow read access to your
repository over HTTP, do something like this:
$ cd /var/www/htdocs/
$ git clone --bare /path/to/git_project gitproject.git
$ cd gitproject.git
$ mv hooks/post-update.sample hooks/post-update
$ chmod a+x hooks/post-update
That’s all. The post-update hook that comes with Git by default runs the
appropriate command (git update-server-info) to make HTTP fetching
and cloning work properly. This command is run when you push to this reposi-
tory (over SSH perhaps); then, other people can clone via something like
CHAPTER 4: Git en el Servidor
$ git clone
In this particular case, we’re using the /var/www/htdocs path that is com-
mon for Apache setups, but you can use any static web server – just put the
bare repository in its path. The Git data is served as basic static files (see Chap-
ter 10 for details about exactly how it’s served).
Generally you would either choose to run a read/write Smart HTTP server or
simply have the files accessible as read-only in the Dumb manner. It’s rare to
run a mix of the two services.
We’ll concentrate on the pros of the Smart version of the HTTP protocol.
The simplicity of having a single URL for all types of access and having the
server prompt only when authentication is needed makes things very easy for
the end user. Being able to authenticate with a username and password is also
a big advantage over SSH, since users don’t have to generate SSH keys locally
and upload their public key to the server before being able to interact with it.
For less sophisticated users, or users on systems where SSH is less common,
this is a major advantage in usability. It is also a very fast and eicient protocol,
similar to the SSH one.
You can also serve your repositories read-only over HTTPS, which means you
can encrypt the content transfer; or you can go so far as to make the clients use
specific signed SSL certificates.
Another nice thing is that HTTP/S are such commonly used protocols that
corporate firewalls are oen set up to allow traic through these ports.
Git over HTTP/S can be a little more tricky to set up compared to SSH on some
servers. Other than that, there is very little advantage that other protocols have
over the “Smart” HTTP protocol for serving Git.
If you’re using HTTP for authenticated pushing, providing your credentials is
sometimes more complicated than using keys over SSH. There are however sev-
eral credential caching tools you can use, including Keychain access on OSX
and Credential Manager on Windows, to make this pretty painless. Read “Cre-
dential Storage” to see how to set up secure HTTP password caching on your
The Protocols
The SSH Protocol
A common transport protocol for Git when self-hosting is over SSH. This is be-
cause SSH access to servers is already set up in most places – and if it isn’t, it’s
easy to do. SSH is also an authenticated network protocol; and because it’s
ubiquitous, it’s generally easy to set up and use.
To clone a Git repository over SSH, you can specify ssh:// URL like this:
$ git clone ssh://user@server/project.git
Or you can use the shorter scp-like syntax for the SSH protocol:
$ git clone user@server:project.git
You can also not specify a user, and Git assumes the user you’re currently
logged in as.
The pros of using SSH are many. First, SSH is relatively easy to set up – SSH dae-
mons are commonplace, many network admins have experience with them,
and many OS distributions are set up with them or have tools to manage them.
Next, access over SSH is secure – all data transfer is encrypted and authentica-
ted. Last, like the HTTP/S, Git and Local protocols, SSH is eicient, making the
data as compact as possible before transferring it.
The negative aspect of SSH is that you can’t serve anonymous access of your
repository over it. People must have access to your machine over SSH to access
it, even in a read-only capacity, which doesn’t make SSH access conducive to
open source projects. If you’re using it only within your corporate network, SSH
may be the only protocol you need to deal with. If you want to allow anony-
mous read-only access to your projects and also want to use SSH, you’ll have to
set up SSH for you to push over but something else for others to fetch over.
The Git Protocol
Next is the Git protocol. This is a special daemon that comes packaged with Git;
it listens on a dedicated port (9418) that provides a service similar to the SSH
CHAPTER 4: Git en el Servidor
protocol, but with absolutely no authentication. In order for a repository to be
served over the Git protocol, you must create the git-daemon-export-ok file
– the daemon won’t serve a repository without that file in it – but other than
that there is no security. Either the Git repository is available for everyone to
clone or it isn’t. This means that there is generally no pushing over this proto-
col. You can enable push access; but given the lack of authentication, if you turn
on push access, anyone on the internet who finds your project’s URL could push
to your project. Suice it to say that this is rare.
The Git protocol is oen the fastest network transfer protocol available. If
you’re serving a lot of traic for a public project or serving a very large project
that doesn’t require user authentication for read access, it’s likely that you’ll
want to set up a Git daemon to serve your project. It uses the same data-
transfer mechanism as the SSH protocol but without the encryption and au-
thentication overhead.
The downside of the Git protocol is the lack of authentication. It’s generally un-
desirable for the Git protocol to be the only access to your project. Generally,
you’ll pair it with SSH or HTTPS access for the few developers who have push
(write) access and have everyone else use git:// for read-only access. It’s also
probably the most diicult protocol to set up. It must run its own daemon,
which requires xinetd configuration or the like, which isn’t always a walk in
the park. It also requires firewall access to port 9418, which isn’t a standard
port that corporate firewalls always allow. Behind big corporate firewalls, this
obscure port is commonly blocked.
Configurando Git en un servidor
Ahora vamos a cubrir la creación de un servicio de Git ejecutando estos proto-
colos en su propio servidor.
Aquí demostraremos los comandos y pasos necesarios para hacer las in-
stalaciones básicas simplificadas en un servidor basado en Linux, aunque
también es posible ejecutar estos servicios en los servidores Mac o Win-
dows. Configurar un servidor de producción dentro de tu infraestructura
sin duda supondrá diferencias en las medidas de seguridad o de las herra-
mientas del sistema operativo, pero se espera que esto le de la idea gen-
eral de lo que el proceso involucra.
Configurando Git en un servidor
Para configurar por primera vez un servidor de Git, hay que exportar un re-
positorio existente en un nuevo repositorio vacío - un repositorio que no con-
tiene un directorio de trabajo. Esto es generalmente fácil de hacer. Para clonar
el repositorio con el fin de crear un nuevo repositorio vacío, se ejecuta el co-
mando clone con la opción --bare. Por convención, los directorios del reposi-
torio vacío terminan en .git , así:
$ git clone --bare my_project my_project.git
Cloning into bare repository 'my_project.git'...
Deberías tener ahora una copia de los datos del directorio Git en tu director-
io my_project.git. Esto es más o menos equivalente a algo así:
$ cp -Rf my_project/.git my_project.git
Hay un par de pequeñas diferencias en el archivo de configuración; pero
para tú propósito, esto es casi la misma cosa. Toma el repositorio Git en sí mis-
mo, sin un directorio de trabajo, y crea un directorio específicamente para él
Colocando un Repositorio Vacío en un Servidor
Ahora que tienes una copia vacía de tú repositorio, todo lo que necesitas hacer
es ponerlo en un servidor y establecer sus protocolos. Digamos que has config-
urado un servidor llamado que tiene acceso a SSH, y
quieres almacenar todos tus repositorios Git bajo el directorio / opt` / git`. Su-
poniendo que existe / opt / git en ese servidor, puedes configurar tu nuevo
repositorio copiando tu repositorio vacío a:
$ scp -r my_project.git
En este punto, otros usuarios que con acceso SSH al mismo servidor que
tiene permisos de lectura-acceso al directorio / opt / git pueden clonar tu
repositorio mediante el comando
$ git clone
CHAPTER 4: Git en el Servidor
Si un usuario accede por medio de SSH a un servidor y tiene permisos de
escritura en el directorio git my_project.git / opt / /, automáticamente
también tendrán acceso push.
Git automáticamente agrega permisos de grupo para la escritura en un repo-
sitorio apropiadamente si se ejecuta el comando git init con la opción` --
$ ssh
$ cd /opt/git/my_project.git
$ git init --bare --shared
Puedes ver lo fácil que es tomar un repositorio Git, crear una versión vacía, y
colocarlo en un servidor al que tú y tus colaboradores tienen acceso SSH. Ahora
estan listos para colaborar en el mismo proyecto.
Es importante tener en cuenta que esto es literalmente todo lo que necesitas
hacer para ejecutar un útil servidor Git al cual varias personas tendrán acceso -
sólo tiene que añadir cuentas con acceso SSH a un servidor, y subir un reposi-
torio vacío en alguna parte a la que todos los usuarios puedan leer y escribir.
Estás listo para trabajar. Nada más es necesario.
En las próximas secciones, verás cómo ampliar a configuraciones más sofis-
ticadas. Esta sección incluirá no tener que crear cuentas para cada usuario,
añadiendo permisos de lectura pública a los repositorios, la creación de inter-
faces de usuario web y más. Sin embargo, ten en cuenta que para colaborar con
un par de personas en un proyecto privado, todo_lo_que_necesitas_es un ser-
vidor SSH y un repositorio vacío.
Pequeñas configuraciones
Si tienes un pequeño equipo o acabas de probar Git en tr organización y tienes
sólo unos pocos desarrolladores, las cosas pueden ser simples para tí. Uno de
los aspectos más complicados de configurar un servidor Git es la gestión de
usuarios. Si quieres que algunos repositorios sean de sólo lectura para ciertos
usuarios y lectura / escritura para los demás, el acceso y los permisos pueden
ser un poco más difíciles de organizar.
Si tienes un servidor al que todos los desarrolladores ya tienen acceso SSH, es
generalmente más fácil de configurar el primer repositorio allí, porque no hay
que hacer casi ningún trabajo (como ya vimos en la sección anterior). Si quieres
permisos de acceso más complejas en tus repositorios, puedes manejarlos con
Configurando Git en un servidor
los permisos del sistema de archivos normales del sistema operativo donde tu
servidor se ejecuta.
Si deseas colocar los repositorios en un servidor que no tiene cuentas para
todo el mundo en su equipo para el que deseas tener acceso de escritura,
debes configurar el acceso SSH para ellos. Suponiendo que tienes un servidor
con el que hacer esto, ya tiene un servidor SSH instalado, y así es como estás
accediendo al servidor.
Hay algunas maneras con las cuales puedes dar acceso a todo tu equipo. La
primera es la creación de cuentas para todo el mundo, que es sencillo, pero
puede ser engorroso. Podrías no desear ejecutar adduser y establecer contras-
eñas temporales para cada usuario.
Un segundo método consiste en crear un solo usuario git en la máquina,
preguntar a cada usuario de quién se trata para otorgarle permisos de escritura
para que te envíe una llave SSH pública, y agregar esa llave al archivo
~ / .ssh / authorized_keys de tu nuevo usuario git. En ese momento, to-
do el mundo podrá acceder a esa máquina mediante el usuario git. Esto no
afecta a los datos commit de ninguna manera - el usuario SSH con el que te
conectas no puede modificar los commits que has registrado.
Otra manera de hacer que tu servidor SSH autentifique desde un servidor
LDAP o desde alguna otra fuente de autentificación centralizada que pudieras
tener ya configurada. Mientras que cada usuario sea capaz de tener acceso shell
a la máquina, cualquier mecanismo de autentificación SSH que se te ocurra de-
bería de funcionar.
Generating Your SSH Public Key
That being said, many Git servers authenticate using SSH public keys. In order
to provide a public key, each user in your system must generate one if they
don’t already have one. This process is similar across all operating systems.
First, you should check to make sure you don’t already have a key. By default, a
user’s SSH keys are stored in that user’s ~/.ssh directory. You can easily check
to see if you have a key already by going to that directory and listing the con-
$ cd ~/.ssh
$ ls
authorized_keys2 id_dsa known_hosts
You’re looking for a pair of files named something like id_dsa or id_rsa
and a matching file with a .pub extension. The .pub file is your public key, and
CHAPTER 4: Git en el Servidor
the other file is your private key. If you don’t have these files (or you don’t even
have a .ssh directory), you can create them by running a program called ssh-
keygen, which is provided with the SSH package on Linux/Mac systems and
comes with the MSysGit package on Windows:
$ ssh-keygen
Generating public/private rsa key pair.
Enter file in which to save the key (/home/schacon/.ssh/id_rsa):
Created directory '/home/schacon/.ssh'.
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in /home/schacon/.ssh/id_rsa.
Your public key has been saved in /home/schacon/.ssh/
The key fingerprint is:
d0:82:24:8e:d7:f1:bb:9b:33:53:96:93:49:da:9b:e3 schacon@mylaptop.local
First it confirms where you want to save the key (.ssh/id_rsa), and then it
asks twice for a passphrase, which you can leave empty if you don’t want to
type a password when you use the key.
Now, each user that does this has to send their public key to you or whoever
is administrating the Git server (assuming you’re using an SSH server setup that
requires public keys). All they have to do is copy the contents of the .pub file
and e-mail it. The public keys look something like this:
$ cat ~/.ssh/
NrRFi9wrf+M7Q== schacon@mylaptop.local
For a more in-depth tutorial on creating an SSH key on multiple operating
systems, see the GitHub guide on SSH keys at
Setting Up the Server
Let’s walk through setting up SSH access on the server side. In this example,
you’ll use the authorized_keys method for authenticating your users. We al-
so assume you’re running a standard Linux distribution like Ubuntu. First, you
create a git user and a .ssh directory for that user.
Setting Up the Server
$ sudo adduser git
$ su git
$ cd
$ mkdir .ssh && chmod 700 .ssh
$ touch .ssh/authorized_keys && chmod 600 .ssh/authorized_keys
Next, you need to add some developer SSH public keys to the author-
ized_keys file for the git user. Let’s assume you have some trusted public
keys and have saved them to temporary files. Again, the public keys look some-
thing like this:
$ cat /tmp/
ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQCB007n/ww+ouN4gSLKssMxXnBOvf9LGt4L
dAv8JggJICUvax2T9va5 gsg-keypair
You just append them to the git user’s authorized_keys file in its .ssh
$ cat /tmp/ >> ~/.ssh/authorized_keys
$ cat /tmp/ >> ~/.ssh/authorized_keys
$ cat /tmp/ >> ~/.ssh/authorized_keys
Now, you can set up an empty repository for them by running git init
with the --bare option, which initializes the repository without a working di-
$ cd /opt/git
$ mkdir project.git
$ cd project.git
$ git init --bare
Initialized empty Git repository in /opt/git/project.git/
Then, John, Josie, or Jessica can push the first version of their project into
that repository by adding it as a remote and pushing up a branch. Note that
someone must shell onto the machine and create a bare repository every time
you want to add a project. Let’s use gitserver as the hostname of the server
on which you’ve set up your git user and repository. If you’re running it inter-
CHAPTER 4: Git en el Servidor
nally, and you set up DNS for gitserver to point to that server, then you can
use the commands pretty much as is (assuming that myproject is an existing
project with files in it):
# on Johns computer
$ cd myproject
$ git init
$ git add .
$ git commit -m 'initial commit'
$ git remote add origin git@gitserver:/opt/git/project.git
$ git push origin master
At this point, the others can clone it down and push changes back up just as
$ git clone git@gitserver:/opt/git/project.git
$ cd project
$ vim README
$ git commit -am 'fix for the README file'
$ git push origin master
With this method, you can quickly get a read/write Git server up and running
for a handful of developers.
You should note that currently all these users can also log into the server
and get a shell as the git user. If you want to restrict that, you will have to
change the shell to something else in the passwd file.
You can easily restrict the git user to only doing Git activities with a limited
shell tool called git-shell that comes with Git. If you set this as your git
user’s login shell, then the git user can’t have normal shell access to your serv-
er. To use this, specify git-shell instead of bash or csh for your user’s login
shell. To do so, you must first add git-shell to /etc/shells if it’s not already
$ cat /etc/shells # see if `git-shell` is already in there. If not...
$ which git-shell # make sure git-shell is installed on your system.
$ sudo vim /etc/shells # and add the path to git-shell from last command
Now you can edit the shell for a user using chsh <username>:
$ sudo chsh git # and enter the path to git-shell, usually: /usr/bin/git-shell
Setting Up the Server
Now, the git user can only use the SSH connection to push and pull Git re-
positories and can’t shell onto the machine. If you try, you’ll see a login rejec-
tion like this:
$ ssh git@gitserver
fatal: Interactive git shell is not enabled.
hint: ~/git-shell-commands should exist and have read and execute access.
Connection to gitserver closed.
Now Git network commands will still work just fine but the users won’t be
able to get a shell. As the output states, you can also set up a directory in the
git user’s home directory that customizes the git-shell command a bit. For
instance, you can restrict the Git commands that the server will accept or you
can customize the message that users see if they try to SSH in like that. Run git
help shell for more information on customizing the shell.
Git Daemon
Next we’ll set up a daemon serving repositories over the “Git” protocol. This is
common choice for fast, unauthenticated access to your Git data. Remember
that since it’s not an authenticated service, anything you serve over this proto-
col is public within its network.
If you’re running this on a server outside your firewall, it should only be used
for projects that are publicly visible to the world. If the server you’re running it
on is inside your firewall, you might use it for projects that a large number of
people or computers (continuous integration or build servers) have read-only
access to, when you don’t want to have to add an SSH key for each.
In any case, the Git protocol is relatively easy to set up. Basically, you need to
run this command in a daemonized manner:
git daemon --reuseaddr --base-path=/opt/git/ /opt/git/
--reuseaddr allows the server to restart without waiting for old connec-
tions to time out, the --base-path option allows people to clone projects
without specifying the entire path, and the path at the end tells the Git daemon
where to look for repositories to export. If you’re running a firewall, you’ll also
need to punch a hole in it at port 9418 on the box you’re setting this up on.
You can daemonize this process a number of ways, depending on the operat-
ing system you’re running. On an Ubuntu machine, you can use an Upstart
script. So, in the following file
CHAPTER 4: Git en el Servidor
you put this script:
start on startup
stop on shutdown
exec /usr/bin/git daemon \
--user=git --group=git \
--reuseaddr \
--base-path=/opt/git/ \
For security reasons, it is strongly encouraged to have this daemon run as a
user with read-only permissions to the repositories – you can easily do this by
creating a new user git-ro and running the daemon as them. For the sake of
simplicity we’ll simply run it as the same git user that git-shell is running as.
When you restart your machine, your Git daemon will start automatically
and respawn if it goes down. To get it running without having to reboot, you
can run this:
initctl start local-git-daemon
On other systems, you may want to use xinetd, a script in your sysvinit
system, or something else – as long as you get that command daemonized and
watched somehow.
Next, you have to tell Git which repositories to allow unauthenticated Git
server-based access to. You can do this in each repository by creating a file
name git-daemon-export-ok.
$ cd /path/to/project.git
$ touch git-daemon-export-ok
The presence of that file tells Git that it’s OK to serve this project without au-
Git Daemon
Smart HTTP
We now have authenticated access though SSH and unauthenticated access
through git://, but there is also a protocol that can do both at the same time.
Setting up Smart HTTP is basically just enabling a CGI script that is provided
with Git called git-http-backend on the server. This CGI will read the path
and headers sent by a git fetch or git push to an HTTP URL and determine
if the client can communicate over HTTP (which is true for any client since ver-
sion 1.6.6). If the CGI sees that the client is smart, it will communicate smartly
with it, otherwise it will fall back to the dumb behavior (so it is backward com-
patible for reads with older clients).
Let’s walk through a very basic setup. We’ll set this up with Apache as the
CGI server. If you don’t have Apache setup, you can do so on a Linux box with
something like this:
$ sudo apt-get install apache2 apache2-utils
$ a2enmod cgi alias env
This also enables the mod_cgi, mod_alias, and mod_env modules, which
are all needed for this to work properly.
Next we need to add some things to the Apache configuration to run the
git-http-backend as the handler for anything coming into the /git path of
your web server.
SetEnv GIT_PROJECT_ROOT /opt/git
ScriptAlias /git/ /usr/libexec/git-core/git-http-backend/
If you leave out GIT_HTTP_EXPORT_ALL environment variable, then Git will
only serve to unauthenticated clients the repositories with the git-daemon-
export-ok file in them, just like the Git daemon did.
Then you’ll have to tell Apache to allow requests to that path with some-
thing like this:
<Directory "/usr/lib/git-core*">
Options ExecCGI Indexes
Order allow,deny
Allow from all
Require all granted
CHAPTER 4: Git en el Servidor
Finally you’ll want to make writes be authenticated somehow, possibly with
an Auth block like this:
<LocationMatch "^/git/.*/git-receive-pack$">
AuthType Basic
AuthName "Git Access"
AuthUserFile /opt/git/.htpasswd
Require valid-user
That will require you to create a .htaccess file containing the passwords of
all the valid users. Here is an example of adding a “schacon” user to the file:
$ htdigest -c /opt/git/.htpasswd "Git Access" schacon
There are tons of ways to have Apache authenticate users, you’ll have to
choose and implement one of them. This is just the simplest example we could
come up with. You’ll also almost certainly want to set this up over SSL so all this
data is encrypted.
We don’t want to go too far down the rabbit hole of Apache configuration
specifics, since you could well be using a dierent server or have dierent au-
thentication needs. The idea is that Git comes with a CGI called git-http-
backend that when invoked will do all the negotiation to send and receive data
over HTTP. It does not implement any authentication itself, but that can easily
be controlled at the layer of the web server that invokes it. You can do this with
nearly any CGI-capable web server, so go with the one that you know best.
For more information on configuring authentication in Apache, check
out the Apache docs here:
Now that you have basic read/write and read-only access to your project, you
may want to set up a simple web-based visualizer. Git comes with a CGI script
called GitWeb that is sometimes used for this.
The GitWeb web-
based user interface.
If you want to check out what GitWeb would look like for your project, Git
comes with a command to fire up a temporary instance if you have a light-
weight server on your system like lighttpd or webrick. On Linux machines,
lighttpd is oen installed, so you may be able to get it to run by typing git
instaweb in your project directory. If you’re running a Mac, Leopard comes
preinstalled with Ruby, so webrick may be your best bet. To start instaweb
with a non-lighttpd handler, you can run it with the --httpd option.
$ git instaweb --httpd=webrick
[2009-02-21 10:02:21] INFO WEBrick 1.3.1
[2009-02-21 10:02:21] INFO ruby 1.8.6 (2008-03-03) [universal-darwin9.0]
That starts up an HTTPD server on port 1234 and then automatically starts a
web browser that opens on that page. It’s pretty easy on your part. When you’re
done and want to shut down the server, you can run the same command with
the --stop option:
$ git instaweb --httpd=webrick --stop
CHAPTER 4: Git en el Servidor
If you want to run the web interface on a server all the time for your team or
for an open source project you’re hosting, you’ll need to set up the CGI script to
be served by your normal web server. Some Linux distributions have a gitweb
package that you may be able to install via apt or yum, so you may want to try
that first. We’ll walk through installing GitWeb manually very quickly. First, you
need to get the Git source code, which GitWeb comes with, and generate the
custom CGI script:
$ git clone git://
$ cd git/
$ make GITWEB_PROJECTROOT="/opt/git" prefix=/usr gitweb
SUBDIR gitweb
make[2]: `GIT-VERSION-FILE' is up to date.
GEN gitweb.cgi
GEN static/gitweb.js
$ sudo cp -Rf gitweb /var/www/
Notice that you have to tell the command where to find your Git repositories
with the GITWEB_PROJECTROOT variable. Now, you need to make Apache use
CGI for that script, for which you can add a VirtualHost:
<VirtualHost *:80>
ServerName gitserver
DocumentRoot /var/www/gitweb
<Directory /var/www/gitweb>
Options ExecCGI +FollowSymLinks +SymLinksIfOwnerMatch
AllowOverride All
order allow,deny
Allow from all
AddHandler cgi-script cgi
DirectoryIndex gitweb.cgi
Again, GitWeb can be served with any CGI or Perl capable web server; if you
prefer to use something else, it shouldn’t be diicult to set up. At this point, you
should be able to visit http://gitserver/ to view your repositories online.
The Bitnami GitLab
virtual machine
login screen.
GitWeb is pretty simplistic though. If you’re looking for a more modern, fully
featured Git server, there are some several open source solutions out there that
you can install instead. As GitLab is one of the more popular ones, we’ll cover
installing and using it as an example. This is a bit more complex than the Git-
Web option and likely requires more maintenance, but it is a much more fully
featured option.
GitLab is a database-backed web application, so its installation is a bit more in-
volved than some other git servers. Fortunately, this process is very well-
documented and supported.
There are a few methods you can pursue to install GitLab. To get something
up and running quickly, you can download a virtual machine image or a one-
click installer from, and tweak the configura-
tion to match your particular environment. One nice touch Bitnami has includ-
ed is the login screen (accessed by typing alt-→); it tells you the IP address and
default username and password for the installed GitLab.
For anything else, follow the guidance in the GitLab Community Edition re-
adme, which can be found at
master. There you’ll find assistance for installing GitLab using Chef recipes, a
CHAPTER 4: Git en el Servidor
The “Admin area”
item in the GitLab
virtual machine on Digital Ocean, and RPM and DEB packages (which, as of this
writing, are in beta). There’s also “unoicial” guidance on getting GitLab run-
ning with non-standard operating systems and databases, a fully-manual in-
stallation script, and many other topics.
GitLab’s administration interface is accessed over the web. Simply point your
browser to the hostname or IP address where GitLab is installed, and log in as
an admin user. The default username is, and the default
password is 5iveL!fe (which you will be prompted to change as soon as you
enter it). Once logged in, click the “Admin area” icon in the menu at the top
Users in GitLab are accounts that correspond to people. User accounts don’t
have a lot of complexity; mainly it’s a collection of personal information attach-
ed to login data. Each user account comes with a namespace, which is a logical
grouping of projects that belong to that user. If the user jane had a project
named project, that project’s url would be http://server/jane/project.
The GitLab user
Removing a user can be done in two ways. “Blocking” a user prevents them
from logging into the GitLab instance, but all of the data under that user’s
namespace will be preserved, and commits signed with that user’s email ad-
dress will still link back to their profile.
“Destroying” a user, on the other hand, completely removes them from the
database and filesystem. All projects and data in their namespace is removed,
and any groups they own will also be removed. This is obviously a much more
permanent and destructive action, and its uses are rare.
A GitLab group is an assemblage of projects, along with data about how users
can access those projects. Each group has a project namespace (the same way
that users do), so if the group training has a project materials, its url would
be http://server/training/materials.
CHAPTER 4: Git en el Servidor
The GitLab group
Each group is associated with a number of users, each of which has a level of
permissions for the groups projects and the group itself. These range from
“Guest” (issues and chat only) to “Owner” (full control of the group, its mem-
bers, and its projects). The types of permissions are too numerous to list here,
but GitLab has a helpful link on the administration screen.
A GitLab project roughly corresponds to a single git repository. Every project
belongs to a single namespace, either a user or a group. If the project belongs
to a user, the owner of the project has direct control over who has access to the
project; if the project belongs to a group, the groups user-level permissions will
also take eect.
Every project also has a visibility level, which controls who has read access
to that project’s pages and repository. If a project is Private, the project’s owner
must explicitly grant access to specific users. An Internal project is visible to any
logged-in user, and a Public project is visible to anyone. Note that this controls
both git “fetch” access as well as access to the web UI for that project.
GitLab includes support for hooks, both at a project or system level. For either
of these, the GitLab server will perform an HTTP POST with some descriptive
JSON whenever relevant events occur. This is a great way to connect your git
repositories and GitLab instance to the rest of your development automation,
such as CI servers, chat rooms, or deployment tools.
Basic Usage
The first thing you’ll want to do with GitLab is create a new project. This is ac-
complished by clicking the “+” icon on the toolbar. You’ll be asked for the
project’s name, which namespace it should belong to, and what its visibility lev-
el should be. Most of what you specify here isn’t permanent, and can be re-
adjusted later through the settings interface. Click “Create Project”, and you’re
Once the project exists, you’ll probably want to connect it with a local Git
repository. Each project is accessible over HTTPS or SSH, either of which can be
used to configure a Git remote. The URLs are visible at the top of the project’s
home page. For an existing local repository, this command will create a remote
named gitlab to the hosted location:
$ git remote add gitlab https://server/namespace/project.git
If you don’t have a local copy of the repository, you can simply do this:
$ git clone https://server/namespace/project.git
The web UI provides access to several useful views of the repository itself.
Each project’s home page shows recent activity, and links along the top will
lead you to views of the project’s files and commit log.
Working Together
The simplest way of working together on a GitLab project is by giving another
user direct push access to the git repository. You can add a user to a project by
going to the “Members” section of that project’s settings, and associating the
new user with an access level (the dierent access levels are discussed a bit in
“Groups). By giving a user an access level of “Developer” or above, that user
can push commits and branches directly to the repository with impunity.
Another, more decoupled way of collaboration is by using merge requests.
This feature enables any user that can see a project to contribute to it in a con-
trolled way. Users with direct access can simply create a branch, push commits
to it, and open a merge request from their branch back into master or any oth-
er branch. Users who don’t have push permissions for a repository can “fork” it
(create their own copy), push commits to that copy, and open a merge request
from their fork back to the main project. This model allows the owner to be in
CHAPTER 4: Git en el Servidor
full control of what goes into the repository and when, while allowing contribu-
tions from untrusted users.
Merge requests and issues are the main units of long-lived discussion in Gi-
tLab. Each merge request allows a line-by-line discussion of the proposed
change (which supports a lightweight kind of code review), as well as a general
overall discussion thread. Both can be assigned to users, or organized into mile-
This section is focused mainly on the Git-related features of GitLab, but as a
mature project, it provides many other features to help your team work togeth-
er, such as project wikis and system maintenance tools. One benefit to GitLab is
that, once the server is set up and running, you’ll rarely need to tweak a config-
uration file or access the server via SSH; most administration and general usage
can be accomplished through the in-browser interface.
Third Party Hosted Options
If you don’t want to go through all of the work involved in setting up your own
Git server, you have several options for hosting your Git projects on an external
dedicated hosting site. Doing so oers a number of advantages: a hosting site is
generally quick to set up and easy to start projects on, and no server mainte-
nance or monitoring is involved. Even if you set up and run your own server in-
ternally, you may still want to use a public hosting site for your open source
code – it’s generally easier for the open source community to find and help you
These days, you have a huge number of hosting options to choose from,
each with dierent advantages and disadvantages. To see an up-to-date list,
check out the GitHosting page on the main Git wiki at https://
We’ll cover using GitHub in detail in Chapter 6, as it is the largest Git host
out there and you may need to interact with projects hosted on it in any case,
but there are dozens more to choose from should you not want to set up your
own Git server.
Tienes varias opciones para obtener un repositorio Git remoto y ponerlo a fun-
cionar para que puedas colaborar con otras personas o compartir tu trabajo.
Mantener tu propio servidor te da control y te permite correr tu servidor
dentro de tu propio cortafuegos, pero tal servidor generalmente requiere una
importante cantidad de tu tiempo para configurar y mantener. Si almacenas tus
datos en un servidor hospedado, es fácil de configurar y mantener; sin embar-
Third Party Hosted Options
go, tienes que ser capaz de mantener tu código en los servidores de alguien
más, y agunas organizaciones no te lo permitirán.
Debería ser un proceso claro determinar que solución o combinación de sol-
uciones es apropiada para tí y para tu organización.
CHAPTER 4: Git en el Servidor
Distributed Git
Now that you have a remote Git repository set up as a point for all the develop-
ers to share their code, and you’re familiar with basic Git commands in a local
workflow, you’ll look at how to utilize some of the distributed workflows that
Git aords you.
In this chapter, you’ll see how to work with Git in a distributed environment
as a contributor and an integrator. That is, you’ll learn how to contribute code
successfully to a project and make it as easy on you and the project maintainer
as possible, and also how to maintain a project successfully with a number of
developers contributing.
Distributed Workflows
Unlike Centralized Version Control Systems (CVCSs), the distributed nature of
Git allows you to be far more flexible in how developers collaborate on projects.
In centralized systems, every developer is a node working more or less equally
on a central hub. In Git, however, every developer is potentially both a node
and a hub – that is, every developer can both contribute code to other reposito-
ries and maintain a public repository on which others can base their work and
which they can contribute to. This opens a vast range of workflow possibilities
for your project and/or your team, so we’ll cover a few common paradigms that
take advantage of this flexibility. We’ll go over the strengths and possible weak-
nesses of each design; you can choose a single one to use, or you can mix and
match features from each.
Centralized Workflow
In centralized systems, there is generally a single collaboration model–the cen-
tralized workflow. One central hub, or repository, can accept code, and every-
one synchronizes their work to it. A number of developers are nodes – consum-
ers of that hub – and synchronize to that one place.
This means that if two developers clone from the hub and both make
changes, the first developer to push their changes back up can do so with no
problems. The second developer must merge in the first one’s work before
pushing changes up, so as not to overwrite the first developer’s changes. This
concept is as true in Git as it is in Subversion (or any CVCS), and this model
works perfectly well in Git.
If you are already comfortable with a centralized workflow in your company
or team, you can easily continue using that workflow with Git. Simply set up a
single repository, and give everyone on your team push access; Git won’t let
users overwrite each other. Say John and Jessica both start working at the
same time. John finishes his change and pushes it to the server. Then Jessica
tries to push her changes, but the server rejects them. She is told that she’s try-
ing to push non-fast-forward changes and that she won’t be able to do so until
she fetches and merges. This workflow is attractive to a lot of people because
it’s a paradigm that many are familiar and comfortable with.
This is also not limited to small teams. With Git’s branching model, it’s possi-
ble for hundreds of developers to successfully work on a single project through
dozens of branches simultaneously.
Integration-Manager Workflow
Because Git allows you to have multiple remote repositories, it’s possible to
have a workflow where each developer has write access to their own public
repository and read access to everyone else’s. This scenario oen includes a
canonical repository that represents the “oicial” project. To contribute to that
project, you create your own public clone of the project and push your changes
to it. Then, you can send a request to the maintainer of the main project to pull
in your changes. The maintainer can then add your repository as a remote, test
CHAPTER 5: Distributed Git
manager workow.
your changes locally, merge them into their branch, and push back to their
repository. The process works as follows (see Figure 5-2):
1. The project maintainer pushes to their public repository.
2. A contributor clones that repository and makes changes.
3. The contributor pushes to their own public copy.
4. The contributor sends the maintainer an e-mail asking them to pull
5. The maintainer adds the contributor’s repo as a remote and merges local-
6. The maintainer pushes merged changes to the main repository.
This is a very common workflow with hub-based tools like GitHub or GitLab,
where it’s easy to fork a project and push your changes into your fork for every-
one to see. One of the main advantages of this approach is that you can contin-
ue to work, and the maintainer of the main repository can pull in your changes
at any time. Contributors don’t have to wait for the project to incorporate their
changes – each party can work at their own pace.
Dictator and Lieutenants Workflow
This is a variant of a multiple-repository workflow. It’s generally used by huge
projects with hundreds of collaborators; one famous example is the Linux ker-
nel. Various integration managers are in charge of certain parts of the reposito-
ry; they’re called lieutenants. All the lieutenants have one integration manager
known as the benevolent dictator. The benevolent dictator’s repository serves
as the reference repository from which all the collaborators need to pull. The
process works like this (see Figure 5-3):
Distributed Workflows
Benevolent dictator
1. Regular developers work on their topic branch and rebase their work on
top of master. The master branch is that of the dictator.
2. Lieutenants merge the developers’ topic branches into their master
3. The dictator merges the lieutenants’ master branches into the dictator’s
master branch.
4. The dictator pushes their master to the reference repository so the other
developers can rebase on it.
This kind of workflow isn’t common, but can be useful in very big projects, or
in highly hierarchical environments. It allows the project leader (the dictator) to
delegate much of the work and collect large subsets of code at multiple points
before integrating them.
Workflows Summary
These are some commonly used workflows that are possible with a distributed
system like Git, but you can see that many variations are possible to suit your
particular real-world workflow. Now that you can (hopefully) determine which
workflow combination may work for you, we’ll cover some more specific exam-
ples of how to accomplish the main roles that make up the dierent flows. In
the next section, you’ll learn about a few common patterns for contributing to a
CHAPTER 5: Distributed Git
Contributing to a Project
The main diiculty with describing how to contribute to a project is that there
are a huge number of variations on how it’s done. Because Git is very flexible,
people can and do work together in many ways, and it’s problematic to de-
scribe how you should contribute – every project is a bit dierent. Some of the
variables involved are active contributor count, chosen workflow, your commit
access, and possibly the external contribution method.
The first variable is active contributor count – how many users are actively
contributing code to this project, and how oen? In many instances, you’ll have
two or three developers with a few commits a day, or possibly less for some-
what dormant projects. For larger companies or projects, the number of devel-
opers could be in the thousands, with hundreds or thousands of commits com-
ing in each day. This is important because with more and more developers, you
run into more issues with making sure your code applies cleanly or can be easi-
ly merged. Changes you submit may be rendered obsolete or severely broken
by work that is merged in while you were working or while your changes were
waiting to be approved or applied. How can you keep your code consistently up
to date and your commits valid?
The next variable is the workflow in use for the project. Is it centralized, with
each developer having equal write access to the main codeline? Does the
project have a maintainer or integration manager who checks all the patches?
Are all the patches peer-reviewed and approved? Are you involved in that pro-
cess? Is a lieutenant system in place, and do you have to submit your work to
them first?
The next issue is your commit access. The workflow required in order to con-
tribute to a project is much dierent if you have write access to the project than
if you don’t. If you don’t have write access, how does the project prefer to ac-
cept contributed work? Does it even have a policy? How much work are you
contributing at a time? How oen do you contribute?
All these questions can aect how you contribute eectively to a project and
what workflows are preferred or available to you. We’ll cover aspects of each of
these in a series of use cases, moving from simple to more complex; you should
be able to construct the specific workflows you need in practice from these ex-
Commit Guidelines
Before we start looking at the specific use cases, here’s a quick note about com-
mit messages. Having a good guideline for creating commits and sticking to it
makes working with Git and collaborating with others a lot easier. The Git
Contributing to a Project
Output of git diff
project provides a document that lays out a number of good tips for creating
commits from which to submit patches – you can read it in the Git source code
in the Documentation/SubmittingPatches file.
First, you don’t want to submit any whitespace errors. Git provides an easy
way to check for this – before you commit, run git diff --check, which
identifies possible whitespace errors and lists them for you.
If you run that command before committing, you can tell if you’re about to
commit whitespace issues that may annoy other developers.
Next, try to make each commit a logically separate changeset. If you can, try
to make your changes digestible – don’t code for a whole weekend on five dif-
ferent issues and then submit them all as one massive commit on Monday.
Even if you don’t commit during the weekend, use the staging area on Monday
to split your work into at least one commit per issue, with a useful message per
commit. If some of the changes modify the same file, try to use git add --
patch to partially stage files (covered in detail in “Interactive Staging”). The
project snapshot at the tip of the branch is identical whether you do one com-
mit or five, as long as all the changes are added at some point, so try to make
things easier on your fellow developers when they have to review your changes.
This approach also makes it easier to pull out or revert one of the changesets if
you need to later. “Rewriting History” describes a number of useful Git tricks
for rewriting history and interactively staging files – use these tools to help cra
a clean and understandable history before sending the work to someone else.
The last thing to keep in mind is the commit message. Getting in the habit of
creating quality commit messages makes using and collaborating with Git a lot
easier. As a general rule, your messages should start with a single line that’s no
CHAPTER 5: Distributed Git
more than about 50 characters and that describes the changeset concisely, fol-
lowed by a blank line, followed by a more detailed explanation. The Git project
requires that the more detailed explanation include your motivation for the
change and contrast its implementation with previous behavior – this is a good
guideline to follow. It’s also a good idea to use the imperative present tense in
these messages. In other words, use commands. Instead of “I added tests for
or “Adding tests for,” use “Add tests for.” Here is a template originally written by
Tim Pope:
Short (50 chars or less) summary of changes
More detailed explanatory text, if necessary. Wrap it to
about 72 characters or so. In some contexts, the first
line is treated as the subject of an email and the rest of
the text as the body. The blank line separating the
summary from the body is critical (unless you omit the body
entirely); tools like rebase can get confused if you run
the two together.
Further paragraphs come after blank lines.
- Bullet points are okay, too
- Typically a hyphen or asterisk is used for the bullet,
preceded by a single space, with blank lines in
between, but conventions vary here
If all your commit messages look like this, things will be a lot easier for you
and the developers you work with. The Git project has well-formatted commit
messages – try running git log --no-merges there to see what a nicely for-
matted project-commit history looks like.
In the following examples, and throughout most of this book, for the sake of
brevity this book doesn’t have nicely-formatted messages like this; instead, we
use the -m option to git commit. Do as we say, not as we do.
Private Small Team
The simplest setup you’re likely to encounter is a private project with one or
two other developers. “Private,” in this context, means closed-source – not ac-
cessible to the outside world. You and the other developers all have push ac-
cess to the repository.
In this environment, you can follow a workflow similar to what you might do
when using Subversion or another centralized system. You still get the advan-
tages of things like oline committing and vastly simpler branching and merg-
Contributing to a Project
ing, but the workflow can be very similar; the main dierence is that merges
happen client-side rather than on the server at commit time. Let’s see what it
might look like when two developers start to work together with a shared
repository. The first developer, John, clones the repository, makes a change,
and commits locally. (The protocol messages have been replaced with ... in
these examples to shorten them somewhat.)
# John's Machine
$ git clone john@githost:simplegit.git
Initialized empty Git repository in /home/john/simplegit/.git/
$ cd simplegit/
$ vim lib/simplegit.rb
$ git commit -am 'removed invalid default value'
[master 738ee87] removed invalid default value
1 files changed, 1 insertions(+), 1 deletions(-)
The second developer, Jessica, does the same thing – clones the repository
and commits a change:
# Jessica's Machine
$ git clone jessica@githost:simplegit.git
Initialized empty Git repository in /home/jessica/simplegit/.git/
$ cd simplegit/
$ vim TODO
$ git commit -am 'add reset task'
[master fbff5bc] add reset task
1 files changed, 1 insertions(+), 0 deletions(-)
Now, Jessica pushes her work up to the server:
# Jessica's Machine
$ git push origin master
To jessica@githost:simplegit.git
1edee6b..fbff5bc master -> master
John tries to push his change up, too:
# John's Machine
$ git push origin master
To john@githost:simplegit.git
CHAPTER 5: Distributed Git
John’s divergent
! [rejected] master -> master (non-fast forward)
error: failed to push some refs to 'john@githost:simplegit.git'
John isn’t allowed to push because Jessica has pushed in the meantime.
This is especially important to understand if you’re used to Subversion, be-
cause you’ll notice that the two developers didn’t edit the same file. Although
Subversion automatically does such a merge on the server if dierent files are
edited, in Git you must merge the commits locally. John has to fetch Jessicas
changes and merge them in before he will be allowed to push:
$ git fetch origin
From john@githost:simplegit
+ 049d078...fbff5bc master -> origin/master
At this point, John’s local repository looks something like this:
John has a reference to the changes Jessica pushed up, but he has to merge
them into his own work before he is allowed to push:
$ git merge origin/master
Merge made by recursive.
Contributing to a Project
John’s repository
after merging
John’s history after
pushing to the
origin server.
TODO | 1 +
1 files changed, 1 insertions(+), 0 deletions(-)
The merge goes smoothly – John’s commit history now looks like this:
Now, John can test his code to make sure it still works properly, and then he
can push his new merged work up to the server:
$ git push origin master
To john@githost:simplegit.git
fbff5bc..72bbc59 master -> master
Finally, John’s commit history looks like this:
CHAPTER 5: Distributed Git
Jessica’s topic
Jessica’s history
after fetching John’s
In the meantime, Jessica has been working on a topic branch. She’s created
a topic branch called issue54 and done three commits on that branch. She
hasn’t fetched John’s changes yet, so her commit history looks like this:
Jessica wants to sync up with John, so she fetches:
# Jessica's Machine
$ git fetch origin
From jessica@githost:simplegit
fbff5bc..72bbc59 master -> origin/master
That pulls down the work John has pushed up in the meantime. Jessica’s
history now looks like this:
Jessica thinks her topic branch is ready, but she wants to know what she has
to merge into her work so that she can push. She runs git log to find out:
$ git log --no-merges issue54..origin/master
commit 738ee872852dfaa9d6634e0dea7a324040193016
Author: John Smith <>
Contributing to a Project
Date: Fri May 29 16:01:27 2009 -0700
removed invalid default value
The issue54..origin/master syntax is a log filter that asks Git to only
show the list of commits that are on the latter branch (in this case origin/
master) that are not on the first branch (in this case issue54). We’ll go over
this syntax in detail in “Commit Ranges”.
For now, we can see from the output that there is a single commit that John
has made that Jessica has not merged in. If she merges origin/master, that is
the single commit that will modify her local work.
Now, Jessica can merge her topic work into her master branch, merge John’s
work (origin/master) into her master branch, and then push back to the
server again. First, she switches back to her master branch to integrate all this
$ git checkout master
Switched to branch 'master'
Your branch is behind 'origin/master' by 2 commits, and can be fast-forwarded.
She can merge either origin/master or issue54 first – they’re both up-
stream, so the order doesn’t matter. The end snapshot should be identical no
matter which order she chooses; only the history will be slightly dierent. She
chooses to merge in issue54 first:
$ git merge issue54
Updating fbff5bc..4af4298
Fast forward
README | 1 +
lib/simplegit.rb | 6 +++++-
2 files changed, 6 insertions(+), 1 deletions(-)
No problems occur; as you can see it was a simple fast-forward. Now Jessica
merges in John’s work (origin/master):
$ git merge origin/master
Auto-merging lib/simplegit.rb
Merge made by recursive.
lib/simplegit.rb | 2 +-
1 files changed, 1 insertions(+), 1 deletions(-)
CHAPTER 5: Distributed Git
Jessica’s history
after merging John’s
Jessica’s history
after pushing all
changes back to the
Everything merges cleanly, and Jessica’s history looks like this:
Now origin/master is reachable from Jessicas master branch, so she
should be able to successfully push (assuming John hasn’t pushed again in the
$ git push origin master
To jessica@githost:simplegit.git
72bbc59..8059c15 master -> master
Each developer has committed a few times and merged each other’s work
That is one of the simplest workflows. You work for a while, generally in a
topic branch, and merge into your master branch when it’s ready to be integra-
ted. When you want to share that work, you merge it into your own master
branch, then fetch and merge origin/master if it has changed, and finally
push to the master branch on the server. The general sequence is something
like this:
Contributing to a Project
General sequence of
events for a simple
Git workow.
Private Managed Team
In this next scenario, you’ll look at contributor roles in a larger private group.
You’ll learn how to work in an environment where small groups collaborate on
features and then those team-based contributions are integrated by another
Let’s say that John and Jessica are working together on one feature, while
Jessica and Josie are working on a second. In this case, the company is using a
CHAPTER 5: Distributed Git
type of integration-manager workflow where the work of the individual groups
is integrated only by certain engineers, and the master branch of the main repo
can be updated only by those engineers. In this scenario, all work is done in
team-based branches and pulled together by the integrators later.
Let’s follow Jessica’s workflow as she works on her two features, collaborat-
ing in parallel with two dierent developers in this environment. Assuming she
already has her repository cloned, she decides to work on featureA first. She
creates a new branch for the feature and does some work on it there:
# Jessica's Machine
$ git checkout -b featureA
Switched to a new branch 'featureA'
$ vim lib/simplegit.rb
$ git commit -am 'add limit to log function'
[featureA 3300904] add limit to log function
1 files changed, 1 insertions(+), 1 deletions(-)
At this point, she needs to share her work with John, so she pushes her fea-
tureA branch commits up to the server. Jessica doesn’t have push access to
the master branch – only the integrators do – so she has to push to another
branch in order to collaborate with John:
$ git push -u origin featureA
To jessica@githost:simplegit.git
* [new branch] featureA -> featureA
Jessica e-mails John to tell him that shes pushed some work into a branch
named featureA and he can look at it now. While she waits for feedback from
John, Jessica decides to start working on featureB with Josie. To begin, she
starts a new feature branch, basing it o the server’s master branch:
# Jessica's Machine
$ git fetch origin
$ git checkout -b featureB origin/master
Switched to a new branch 'featureB'
Now, Jessica makes a couple of commits on the featureB branch:
$ vim lib/simplegit.rb
$ git commit -am 'made the ls-tree function recursive'
Contributing to a Project
Jessica’s initial
commit history.
[featureB e5b0fdc] made the ls-tree function recursive
1 files changed, 1 insertions(+), 1 deletions(-)
$ vim lib/simplegit.rb
$ git commit -am 'add ls-files'
[featureB 8512791] add ls-files
1 files changed, 5 insertions(+), 0 deletions(-)
Jessica’s repository looks like this:
She’s ready to push up her work, but gets an e-mail from Josie that a branch
with some initial work on it was already pushed to the server as featureBee