¡Acceso ilimitado 24/7 a todos nuestros libros y vídeos! Descubra la Biblioteca Online ENI. Pulse aquí.
  1. Manuales
  2. Git - Controle la gestión de sus versiones (conceptos, utilización y casos prácticos) (2a edicion)

Git Controle la gestión de sus versiones (conceptos, utilización y casos prácticos) (2a edicion)

  • 5% de descuento en todos los libros, con el código 5DESCUENTO
  • Disponible. Expedido en 24 horas
  • Envío gratis a partir de 25 € de compra
  • Versión online gratis por un año
  • 5% de descuento en todos los libros, con el código 5DESCUENTO
  • Consulta inmediata
  • Versión online digital, no descargable
  • Acceso ilimitado 24/7, durante 10 años
  • Acceso ilimitado 24/7, durante 10 años
  • Todos los libros online de ENI
  • Más de 5 novedades todos los meses
  • Novedades disponibles el mismo día de su publicación
  • Acceso 100% online

Presentación

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

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

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

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

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

Índice

  • Prólogo
    • 1. ¿ A quién va dirigido este libro ?
    • 2. Objetivos del libro
    • 3. Requisitos previos
    • 4. Progresión
    • 5. Detalle de los capítulos
    • 6. Un punto sobre los idiomas
    • 7. Agradecimientos
    • 8. Introducción a Git
  • Git y la gestión de versiones
    • 1. La gestión de versiones
    • 2. Los beneficios de la gestión de versiones
      • 2.1 Una verdadera máquina del tiempo
      • 2.2 Una documentación detallada y fechada
      • 2.3 Una piedra roseta para colaborar
    • 3. Historia de la gestión de versiones
      • 3.1 Sistemas de gestión de versiones locales
      • 3.2 Sistemas de gestión de versiones centralizados
      • 3.3 Sistemas de gestión de versiones descentralizados
    • 4. ¿ Por qué Git ?
  • Instalación de Git
    • 1. Instalación en Linux
      • 1.1 Instalación a partir de paquetes preexistentes
      • 1.2 Instalación a partir de las fuentes
    • 2. Instalación en Mac OS X
    • 3. Instalación en Windows
    • 4. La ayuda de Git
      • 4.1 Aspectos generales
      • 4.2 Tipos de comandos Git
        • 4.2.1 Los comandos de porcelana
        • 4.2.2 Los comandos de fontanería
    • 5. Configuración requerida
      • 5.1 Configurar el nombre de usuario
      • 5.2 Configurar el e-mail de usuario
  • Creación de un repositorio
    • 1. Crear un repositorio local
    • 2. El contenido de la carpeta .git
    • 3. El archivo README
    • 4. Markdown
      • 4.1 Presentación
      • 4.2 Elementos de sintaxis
        • 4.2.1 Títulos
        • 4.2.2 Listas no ordenadas
        • 4.2.3 Listas ordenadas
        • 4.2.4 Poner en negrita
        • 4.2.5 Poner en cursiva
        • 4.2.6 Línea horizontal
        • 4.2.7 Código
        • 4.2.8 Tablas
        • 4.2.9 Enlaces
        • 4.2.10 Notas a pie de página
    • 5. RestructuredText
      • 5.1 Presentación
      • 5.2 Elementos de sintaxis
        • 5.2.1 Títulos
        • 5.2.2 Listas autonumeradas
      • 5.3 Software
    • 6. Herramientas para trabajar con Markdown
      • 6.1 Sublime Text
      • 6.2 Texts
      • 6.3 Ulysses
    • 7. Configurar el repositorio local
      • 7.1 Configuración mínima
      • 7.2 Niveles de configuración
        • 7.2.1 El nivel de sistema
        • 7.2.2 El nivel de usuario
        • 7.2.3 El nivel repositorio
      • 7.3 Los parámetros configurables
        • 7.3.1 Definir el editor de texto
        • 7.3.2 Modelo de commit
        • 7.3.3 Ignorar los archivos
        • 7.3.4 Hashs abreviados
      • 7.4 Definición de alias Git
    • 8. Las opciones de configuración avanzadas
      • 8.1 Paginación
      • 8.2 Expresiones regulares extendidas
      • 8.3 Separador de palabras
      • 8.4 Ancestro común de los conflictos
      • 8.5 Configurar la memoria caché de autentificación
  • Operaciones de archivos y commit
    • 1. Operaciones de archivos y commit
    • 2. Una historia de hash
      • 2.1 Una identificación por contenido
      • 2.2 Riesgo de colisión
      • 2.3 Funcionalidad experimental de hash SHA2-256
    • 3. Las tres zonas de un archivo
      • 3.1 El directorio de trabajo
      • 3.2 El índice
      • 3.3 El repositorio
    • 4. Operar con archivos
      • 4.1 Añadir archivos al índice
      • 4.2 Mover o renombrar archivos
      • 4.3 Borrar archivos
      • 4.4 Dejar de seguir un archivo
      • 4.5 Ignorar los archivos
    • 5. Commit o guardar los cambios
      • 5.1 Efectuar un primer commit
      • 5.2 Escribir un buen mensaje de commit
        • 5.2.1 Las reglas de un mensaje de commit
        • 5.2.2 Método para el título
        • 5.2.3 ¿ En qué idioma ?
  • Consulta y operaciones del histórico
    • 1. Listar los commits con git log
      • 1.1 Limitar el número de commits mostrados
      • 1.2 Mostrar las estadísticas
      • 1.3 Mostrar cada commit en una sola línea
      • 1.4 Filtrar los commits cronológicamente
      • 1.5 Filtrar los commits según los participantes
      • 1.6 Mostrar el gráfico de las ramas
      • 1.7 Especificar un formato de salida
      • 1.8 Tener en cuenta los merges
      • 1.9 Listar los commits que afectan a un archivo
      • 1.10 Mostrar las fechas de manera mas legible
    • 2. Mostrar las diferencias de contenido
      • 2.1 Diferencias en curso en el directorio
      • 2.2 Diferencias entre el índice y HEAD
      • 2.3 Diferencias entre el directorio de trabajo y HEAD
      • 2.4 Diferencias introducidas por uno o varios commits
      • 2.5 Diferencias de palabras
      • 2.6 Ver los bloques de código movidos
    • 3. Identificar al autor de una línea de código
    • 4. Buscar los commits con el modo pick axe
    • 5. Eliminar los cambios en el directorio de trabajo
    • 6. Eliminar las modificaciones del índice
    • 7. Volver a un estado anterior
    • 8. Modificar el último commit
    • 9. Ver un resumen de los commits
  • Las ramas y los tags
    • 1. Los tags (etiquetas)
      • 1.1 Numeración de las versiones
      • 1.2 Diferentes tipos de tags
      • 1.3 Creación de los tags
      • 1.4 Creación de un tag anotado
      • 1.5 Lista de tags
      • 1.6 Detalles de un tag
      • 1.7 Envío de los tags al repositorio remoto
      • 1.8 Eliminación de un tag
    • 2. Las ramas (Branch)
      • 2.1 Lista de las ramas existentes
      • 2.2 Creación de una rama
      • 2.3 Posicionamiento en una rama
      • 2.4 Fusionar dos ramas
        • 2.4.1 El avance rápido
        • 2.4.2 Limpiar su repositorio
        • 2.4.3 Los conflictos de fusión
      • 2.5 Eliminar una rama
      • 2.6 Rebasar una rama a otra
  • Compartir un repositorio
    • 1. ¿ Qué es un repositorio remoto ?
    • 2. Crear un repositorio remoto
      • 2.1 Para un nuevo proyecto
      • 2.2 Para un proyecto existente
    • 3. Clonar un repositorio remoto
    • 4. Los protocolos de intercambio
    • 5. Funcionamiento interno y ramas remotas
      • 5.1 Los repositorios remotos vinculados
      • 5.2 Las ramas remotas seguidas
    • 6. Enviar sus modificaciones
    • 7. Recibir las modificaciones
  • Git-Flow: workflow de empresa
    • 1. Un sistema de gestión de ramas
      • 1.1 Las ramas eternas
        • 1.1.1 La rama de producción (master)
        • 1.1.2 La rama de desarrollo (develop)
      • 1.2 Las ramas efímeras
        • 1.2.1 Las ramas de versiones (release)
        • 1.2.2 Las ramas de parches (hotfix)
        • 1.2.3 Las ramas de funcionalidades (feature)
        • 1.2.4 ¿ Varios commits en una rama efímera ?
    • 2. Ejemplo de workflow
    • 3. Git-Flow intuitivo gracias a Tower
      • 3.1 Cliente Git y Git-Flow
      • 3.2 Caso práctico de uso
  • Las herramientas de Git
    • 1. Dejar de lado los cambios con git stash
    • 2. Repositorios integrados con submódulos
      • 2.1 Agregar el repositorio integrado
      • 2.2 Clonar un repositorio y sus repositorios integrados
      • 2.3 Modificación de los repositorios integrados
      • 2.4 Eliminar un repositorio integrado
      • 2.5 Inconvenientes de los repositorios integrados
    • 3. Recuperar un commit erróneo
      • 3.1 Utilización práctica de git bisect
      • 3.2 Automatizar git bisect
    • 4. Registro de referencias (reflog)
    • 5. Los hooks
      • 5.1 Los diferentes tipos de hooks
      • 5.2 ¿ Cómo usar los hooks ?
      • 5.3 Ejemplo de hook: validación de mensajes
      • 5.4 Compartir los hooks en el repositorio
    • 6. Las notas Git
      • 6.1 Crear una nota
      • 6.2 Mostrar las notas
        • 6.2.1 Lista de notas
        • 6.2.2 Ver las notas de un commit
      • 6.3 Editar una nota
      • 6.4 Eliminar una nota
      • 6.5 Enviar notas al servidor
  • Escenario de desarrollador independiente
    • 1. Objetivo del capítulo
    • 2. Contexto del escenario
    • 3. Creación de un repositorio
    • 4. Comienzo del desarrollo
    • 5. Guardar las modificaciones
    • 6. Bitbucket
      • 6.1 Creación de una cuenta
      • 6.2 Enviar un repositorio local a Bitbucket
      • 6.3 Editar un archivo en Bitbucket
      • 6.4 Recuperar las modificaciones del repositorio remoto
    • 7. Integrar un nuevo desarrollo
      • 7.1 Verificar su código antes de la indexación
      • 7.2 Hacer commit del nuevo desarrollo
    • 8. Anular las modificaciones de un archivo
    • 9. .gitignore: ignorar una librería
    • 10. Hacer commit de todos los archivos añadidos o modificados
    • 11. Enviar los commits al repositorio remoto
    • 12. Mostrar las diferencias entre dos commits
    • 13. Clonar el repositorio remoto
    • 14. ¿ Para qué sirve una rama ?
    • 15. Cambiar de rama
    • 16. Fusionar dos ramas
  • Escenario de equipo
    • 1. Contexto del escenario
    • 2. Resumen del proyecto
      • 2.1 Instalación de Python
      • 2.2 Recuperación del repositorio
      • 2.3 Instalación de las dependencias de Python
      • 2.4 Inicialización de los repositorios integrados
      • 2.5 Generación de las librerías
      • 2.6 Creación del archivo de configuración
      • 2.7 Creación de la base de datos
      • 2.8 Creación de una cuenta root
      • 2.9 Ejecución del servidor
    • 3. Instalación de GitLab
    • 4. Creación de cuentas de usuario
    • 5. Creación del proyecto
    • 6. Asignar los proyectos a los usuarios
    • 7. Primer commit del proyecto
      • 7.1 Redacción del archivo .gitignore
        • 7.1.1 Ignorar las librerías
        • 7.1.2 Ignorar los archivos específicos de la tecnología
        • 7.1.3 Ignorar los datos sensibles
        • 7.1.4 Agregar los repositorios integrados
        • 7.1.5 El archivo README
      • 7.2 Commit del proyecto
      • 7.3 Creación de la rama develop para Git-Flow
    • 8. Fase de desarrollo
      • 8.1 Funcionalidad gráfica
      • 8.2 Parche del tiempo negativo
      • 8.3 Integración del parche
      • 8.4 Funcionalidad de tipo tarea
      • 8.5 Finalización de los gráficos
      • 8.6 Finalización de los tipos de tarea
      • 8.7 Creación de la rama de la versión
      • 8.8 Export CSV
      • 8.9 Parche de versión
      • 8.10 Nueva versión estable
      • 8.11 Finalización del export CSV
    • 9. Puesta en línea del repositorio en GitHub
      • 9.1 Creación de una cuenta GitHub
      • 9.2 Creación de un repositorio
      • 9.3 Agregar el repositorio remoto al local
      • 9.4 Envío de las ramas
      • 9.5 El archivo LICENSE
      • 9.6 El archivo README
  • Máxima productividad con Git
    • 1. Alias listos para usar
      • 1.1 Alias simples
        • 1.1.1 git last
        • 1.1.2 git aa
        • 1.1.3 git bv
        • 1.1.4 git ba
        • 1.1.5 git bd
        • 1.1.6 git bdp
        • 1.1.7 git ca
        • 1.1.8 git cb
        • 1.1.9 git cmf
        • 1.1.10 git co
        • 1.1.11 git di
        • 1.1.12 git dc
        • 1.1.13 git mnff
        • 1.1.14 git st
        • 1.1.15 git tg
        • 1.1.16 git pu
        • 1.1.17 git ss
        • 1.1.18 git ssu
        • 1.1.19 git sr
        • 1.1.20 git srp
        • 1.1.21 git sl
        • 1.1.22 git sp
        • 1.1.23 git sa
        • 1.1.24 git sd_f
        • 1.1.25 git sb
        • 1.1.26 git na
        • 1.1.27 git nl
        • 1.1.28 git napp
        • 1.1.29 git ne
        • 1.1.30 git ns
        • 1.1.31 git nr
        • 1.1.32 git ready
      • 1.2 Alias complejos
        • 1.2.1 git bnew
        • 1.2.2 git bold
        • 1.2.3 git ll
        • 1.2.4 git ld
        • 1.2.5 git ls
        • 1.2.6 git ln
        • 1.2.7 git slv
        • 1.2.8 git np
        • 1.2.9 git bvn
        • 1.2.10 git churn
        • 1.2.11 git srr
        • 1.2.12 git spr
        • 1.2.13 git sar
        • 1.2.14 git sdr
      • 1.3 Recuperar los alias en GitHub
    • 2. Comandos listos para usar
      • 2.1 Comandos relacionados con la configuración
        • 2.1.1 Archivo de configuración activo para una opción
        • 2.1.2 Mostrar su configuración
        • 2.1.3 Editar fácilmente un nivel de configuración
      • 2.2 Comandos de visualización
        • 2.2.1 Mostrar los datos técnicos de un commit
        • 2.2.2 Mostrar los padres de los commits
        • 2.2.3 Mostrar archivos en conflicto
        • 2.2.4 Mostrar la lista de archivos modificados
        • 2.2.5 Mostar el ancestro común
        • 2.2.6 Mostrar el primer commit de una rama
        • 2.2.7 Usar git show ocultando el diff
        • 2.2.8 Verificar una rama en un repositorio remoto
        • 2.2.9 Fusionar ramas sin un ancestro común
        • 2.2.10 Mostrar los repositorios remotos y su enlace externo
        • 2.2.11 Mostrar los archivos modificados por un commit
        • 2.2.12 Mostrar la ruta del repositorio versionado
        • 2.2.13 Consultar el histórico de los comandos git
        • 2.2.14 Mostrar el número de commits por autor
        • 2.2.15 Mostrar el número de commits de un autor
        • 2.2.16 Mostrar la última fecha de modificación de las ramas
        • 2.2.17 Listar las ramas que contienen un commit específico
        • 2.2.18 Mostrar el histórico con los diff
        • 2.2.19 Buscar un texto/regex en los commits
        • 2.2.20 Buscar un texto/regex en los stash
        • 2.2.21 Listar los commits de las ramas
        • 2.2.22 Comparar un archivo anterior
        • 2.2.23 Mostrar ramas ya fusionadas en master
        • 2.2.24 Listar las ramas no fusionadas en master
        • 2.2.25 Listar los commits de una rama no fusionada en master
      • 2.3 Comandos de manipulación
        • 2.3.1 Eliminar o revertir cambios en un commit
        • 2.3.2 Eliminar del repositorio los archivos ya eliminados del proyecto
        • 2.3.3 Eliminar cambios del índice
        • 2.3.4 Recuperar el archivo de otro commit
        • 2.3.5 Eliminar archivos no seguidos del directorio
        • 2.3.6 Eliminar las modificaciones de los archivos seguidos
        • 2.3.7 Eliminar una rama distante
  • Git en implementación continua
    • 1. Objetivos del capítulo
    • 2. El proyecto
    • 3. Presentación de Django
    • 4. Desarrollo de la versión inicial
      • 4.1 Instalación
      • 4.2 Creación del proyecto
        • 4.2.1 Creación del proyecto Django
        • 4.2.2 Creación del archivo .gitignore
        • 4.2.3 Registro de bibliotecas de Python
        • 4.2.4 Primer commit
      • 4.3 Creación de aplicaciones de usuarios y artículos
      • 4.4 Creación de modelos Django
        • 4.4.1 El modelo BaseModel
        • 4.4.2 El modelo User
        • 4.4.3 El modelo Article
      • 4.5 Implementación del módulo de administración
        • 4.5.1 Iniciar el servidor de desarrollo
        • 4.5.2 Creación de las páginas de usuario
        • 4.5.3 Templates principales
        • 4.5.4 Lista de los artículos
        • 4.5.5 Página de consulta de un artículo
        • 4.5.6 Página "Quiénes somos"
    • 5. Implementación inicial
      • 5.1 Configuración de los identificadores SSH
      • 5.2 Creación de un sitio web Webfaction
      • 5.3 Creación de las aplicaciones Webfaction
      • 5.4 Creación de la base de datos
      • 5.5 Externialización del repositorio de la configuración
      • 5.6 Preparar la carpeta del proyecto y crear el repositorio
      • 5.7 Configuración del repositorio para la implementación automatizada
      • 5.8 Configuración del remote y primer push
      • 5.9 Creación del entorno virtual
      • 5.10 Configuración de Apache
      • 5.11 Envío de la configuración de producción
      • 5.12 Ejecutar las migraciones
      • 5.13 Sincronizar los archivos estáticos
      • 5.14 Reiniciar Apache
    • 6. Implementación automatizada
      • 6.1 Desarrollo de hook en el repositorio
      • 6.2 Configuración del repositorio remoto
    • 7. Funcionalidad: campo WYSIWYG para el artículo
      • 7.1 Desarrollo
      • 7.2 Implementación automatizada
  • Guía rápida
    • 1. Las referencias
      • 1.1 HEAD
      • 1.2 Las ramas
      • 1.3 Los tags (etiquetas)
      • 1.4 Referencia a ancestros
    • 2. Los comandos
      • 2.1 git add
      • 2.2 git archive
      • 2.3 git bisect
      • 2.4 git blame
      • 2.5 git branch
      • 2.6 git checkout
      • 2.7 git cherry-pick
      • 2.8 git clean
      • 2.9 git clone
      • 2.10 git commit
      • 2.11 git config
      • 2.12 git diff
      • 2.13 git fetch
      • 2.14 git gc
      • 2.15 git help
      • 2.16 git init
      • 2.17 git log
      • 2.18 git merge
      • 2.19 git mv
      • 2.20 git pull
      • 2.21 git push
      • 2.22 git rebase
      • 2.23 git reflog
      • 2.24 git remote
      • 2.25 git reset
      • 2.26 git revert
      • 2.27 git rm
      • 2.28 git show
      • 2.29 git stash
      • 2.30 git submodule
      • 2.31 git tag
      • índice

Autor

Samuel DAUZONMás información

Samuel DAUZON es CTO en Diabolo, una plataforma social de comercio de criptomonedas. Es el creador de Je suis ma santé, una aplicación dedicada a los nutricionistas / dietistas y sus pacientes. Ya autor de los libros Meteor et Ionic para Editions ENI y Django Essentials para Packt Publishing, comparte fácilmente su experiencia en desarrollo web y Git, en beneficio de los lectores.

Características

  • Nivel Experto a Medio
  • Número de páginas 391 páginas
  • Publicación enero 2022
    • Encuadernación rústica - 17 x 21 cm
    • ISBN: 978-2-409-03398-8
    • EAN: 9782409033988
    • Ref. ENI: EPT3GIT
  • Nivel Medio a Experto
  • Publicación enero 2022
    • HTML
    • ISBN: 978-2-409-03399-5
    • EAN: 9782409033995
    • Ref. ENI: LNEPT3GIT

Descargas

Al completar este formulario, acepta recibir información y comunicaciones comerciales sobre nuestros productos y servicios. Puede darse de baja de nuestra newsletter en cualquier momento. Si desea conocer más información acerca de nuestra política de protección de datos, pulse aquí.
  • Descargar los ejemplos del libro (202 Ko)