Introducción a las aplicaciones de OpenShift

Únase a los exploradores, constructores e individuos que, de
manera sólida, ofrecen nuevas soluciones a viejos problemas.
Para el código abierto, la innovación solo es posible gracias a la
gente que está detrás de ella.
LIBRO DE TRABAJO DEL ESTUDIANTE
(ROLE)
OCP 4.2 DO101
INTRODUCCIÓN A LAS APLICACIONES DE
OPENSHIFT
Edición 1
DO101-OCP4.2-es-1-20191127 Copyright ©2019 Red Hat, Inc.

INTRODUCCIÓN A
LAS APLICACIONES
DE OPENSHIFT
DO101-OCP4.2-es-1-20191127 Copyright ©2019 Red Hat, Inc.

OCP 4.2 DO101
Introducción a las aplicaciones de OpenShift
Edición 1 20191127
fecha de publicación 20191127
Autores: Ravi Srinivasan, Herve Quatremain, Dan Kolepp, Zach Gutterman
Editor: Nicole Muller
Copyright ©
The contents of this course and all its modules and related materials, including handouts to audience members, are
Copyright ©
No part of this publication may be stored in a retrieval system, transmitted or reproduced in any way, including, but
not limited to, photocopy, photograph, magnetic, electronic or other record, without the prior written permission of
This instructional program, including all material provided herein, is supplied without any guarantees from Red Hat,
Inc. Red Hat, Inc. assumes no liability for damages or legal action arising from the use or misuse of contents or details
contained herein.
If you believe Red Hat training materials are being used, copied, or otherwise improperly distributed please e-mail
training@redhat.com or phone toll-free (USA) +1 (866) 626-2994 or +1 (919) 754-3700.
Red Hat, Red Hat Enterprise Linux, the Shadowman logo, JBoss, Hibernate, Fedora, the Infinity Logo, and RHCE are
trademarks of Red Hat, Inc., registered in the United States and other countries.
Linux® is the registered trademark of Linus Torvalds in the United States and other countries.
Java® is a registered trademark of Oracle and/or its affiliates.
XFS® is a registered trademark of Silicon Graphics International Corp. or its subsidiaries in the United States and/or
other countries.
The OpenStack® Word Mark and OpenStack Logo are either registered trademarks/service marks or trademarks/
service marks of the OpenStack Foundation, in the United States and other countries and are used with the
OpenStack Foundation's permission. We are not affiliated with, endorsed or sponsored by the OpenStack
Foundation, or the OpenStack community.
All other trademarks are the property of their respective owners.
Colaboradores: Chris Tusa, Heider Souza, Nicolette Lucas, David Sacco, Sajith Sugathan

Convenciones del documento                                                                                          vii
Introducción                                                                                                                     ix
Introducción a las aplicaciones de OpenShift .............................................................. ix
Orientación sobre el entorno del aula ......................................................................... x
Internacionalización .................................................................................................. xi
1. Configuración de un entorno de desarrollador de aplicaciones en la nube                          1
Desarrollo de aplicaciones con Visual Studio Code ....................................................... 2
Ejercicio Guiado: Desarrollo de aplicaciones con Visual Studio Code ............................... 9
Inicialización de un repositorio de Git ........................................................................ 15
Ejercicio Guiado: Inicialización de un repositorio de Git ............................................... 25
Administración del código fuente de la aplicación con Git ............................................ 35
Ejercicio Guiado: Administración del código fuente de la aplicación con Git .................... 45
Resumen ............................................................................................................... 53
2. Implementación de aplicaciones en Red Hat OpenShift Container Platform                    55
Implementación de una aplicación en Red Hat OpenShift Container Platform ................ 56
Ejercicio Guiado: Implementación de una aplicación en Red Hat OpenShift Container
Platform ................................................................................................................ 64
Resumen ............................................................................................................... 69
3. Configuración de compilaciones de aplicaciones en OpenShift                                       71
Actualización de una aplicación ................................................................................ 72
Ejercicio Guiado: Actualización de una aplicación ....................................................... 76
Configuración de contraseñas de la aplicación ........................................................... 86
Ejercicio Guiado: Configuración de contraseñas de la aplicación ................................... 90
Conexión de una aplicación a una base de datos ....................................................... 106
Ejercicio Guiado: Conexión a una base de datos ......................................................... 112
Resumen .............................................................................................................. 128
4. Escalamiento de aplicaciones en OpenShift                                                                 129
Escalamiento de una aplicación .............................................................................. 130
Ejercicio Guiado: Escalamiento de una aplicación ...................................................... 136
Resumen .............................................................................................................. 148
5. Solución de problemas de aplicaciones en OpenShift                                                   149
Solución de problemas y corrección de aplicaciones .................................................. 150
Ejercicio Guiado: Solución de problemas de una aplicación ......................................... 155
Resumen .............................................................................................................. 165
DO101-OCP4.2-es-1-20191127 v

CONVENCIONES DEL DOCUMENTO
REFERENCIAS
"Referencias" describe el lugar donde se puede encontrar documentación externa
relevante para un tema.
NOTA
"Notas" son consejos, atajos o enfoques alternativos para una tarea determinada.
Omitir una nota no debería tener consecuencias negativas, pero quizás se pase por
alto algún truco que pueda simplificar una tarea.
IMPORTANTE
Los cuadros "Importante" detallan cosas que se olvidan con facilidad: cambios
de configuración que solo se aplican a la sesión actual o servicios que se deben
reiniciar para poder aplicar una actualización. Ignorar un cuadro con la etiqueta
"Importante" no provocará pérdida de datos, pero puede causar irritación y
frustración.
ADVERTENCIA
No se deben ignorar las "Advertencias". Es muy probable que omitir las advertencias
provoque pérdida de datos.
DO101-OCP4.2-es-1-20191127 vii

viii DO101-OCP4.2-es-1-20191127

INTRODUCCIÓN
INTRODUCCIÓN A LAS APLICACIONES DE
OPENSHIFT
Red Hat OpenShift Container Platform es una plataforma de aplicaciones
en contenedores que permite a las empresas acelerar y agilizar el desarrollo,
la distribución y la implementación de las aplicaciones en las instalaciones
o la nube. A medida que las empresas continúan adoptando ampliamente
OpenShift y Kubernetes, se exige a los desarrolladores que comprendan
cómo elaborar, crear e implementar aplicaciones con plataformas de
aplicaciones en contenedores. Aunque algunos desarrolladores están
interesados en gestionar la infraestructura subyacente de OpenShift, la
mayoría desea centrar su tiempo y energía en el desarrollo de aplicaciones
y aprovechar OpenShift por sus sencillas capacidades de creación,
implementación y escalabilidad.
La introducción a las aplicaciones de OpenShift (DO101) presenta Red Hat
OpenShift Container Platform a los desarrolladores.
OBJETIVOS DEL
CURSO
• Demostrar los conocimientos básicos
necesarios para implementar, actualizar,
escalar y solucionar problemas de
aplicaciones en OpenShift.
• Demostrar un buen entendimiento de
las ventajas del uso de OpenShift y
cómo contribuir a las aplicaciones que se
implementan en OpenShift.
DESTINATARIOS • Desarrolladores estándar
• Desarrolladores estudiantes
REQUISITOS
PREVIOS
• JB183 o experiencia en programación
equivalente.
DO101-OCP4.2-es-1-20191127 ix

Introducción
ORIENTACIÓN SOBRE EL ENTORNO DEL
AULA
Para este curso, Red Hat Training ha aprovisionado una cuenta para usted en un clúster
compartido de Red Hat OpenShift 4. Al aprovisionar su entorno en la interfaz de Red Hat Online
Learning, el sistema proporciona la información del clúster. La interfaz proporciona la URL de la
consola web de OpenShift, el nombre de usuario y la contraseña.
DO101 es una clase BYOD (uso de dispositivos propios), donde puede usar su propio sistema
compatible con Internet para acceder al clúster compartido de OpenShift. Se admiten los
siguientes sistemas operativos:
• Red Hat Enterprise Linux 8 o Fedora Workstation 30 o posterior
• Ubuntu 18.04 LTS o posterior
• Microsoft Windows 10
• macOS 10.13 o posterior
Debe tener permisos para instalar software adicional en su sistema. Algunas actividades prácticas
de aprendizaje de DO101 proporcionan instrucciones para instalar los siguientes programas:
• Visual Studio Code
• Node.js
• Git
• CLI de OpenShift (oc)
No instale estas herramientas antes del día o este curso si aún no las tiene a fin de garantizar una
experiencia uniforme en el curso.
Las actividades prácticas además requieren que tenga una cuenta personal en GitHub, un servicio
de Internet público y gratuito. Una de las primeras actividades prácticas indica que cree esta
cuenta si aún no tiene una.
x DO101-OCP4.2-es-1-20191127

Introducción
INTERNACIONALIZACIÓN
SELECCIÓN DE IDIOMA POR USUARIO
Es posible que sus usuarios prefieran usar un idioma para su entorno de escritorio distinto al
predeterminado del sistema. Quizás también quieran usar una distribución del teclado o un
método de entrada distintos para su cuenta.
Configuración de idioma
En el entorno de escritorio GNOME, posiblemente el usuario deba definir el idioma de su
preferencia y el método de entrada la primera vez que inicie sesión. Si no es así, la manera más
simple para un usuario individual de definir el idioma de su preferencia y el método de entrada es
usando la aplicación Region & Language.
Puede iniciar esta aplicación de dos maneras. Puede ejecutar el comando gnome-control-
center region desde una ventana de terminal o, en la barra superior, desde el menú del
sistema en la esquina derecha, puede seleccionar el botón de configuración (que tiene un ícono de
destornillador y llave cruzados) desde la parte inferior izquierda del menú.
En la ventana que se abre, seleccione Region & Language (Región e idioma). El usuario puede
hacer clic en el cuadro Language (Idioma) y seleccionar el idioma de su preferencia de la lista que
aparece. Esto también actualiza la configuración de Formats (Formatos) mediante la adopción
del valor predeterminado para ese idioma. La próxima vez que inicie sesión, se efectuarán los
cambios.
Estas configuraciones afectan el entorno de escritorio GNOME y todas las aplicaciones, como
gnome-terminal, que se inician dentro de este. Sin embargo, de forma predeterminada, no se
aplican a la cuenta si el acceso a ella es mediante un inicio de sesión de ssh desde un sistema
remoto o un inicio de sesión basado en texto en una consola virtual (como tty5).
NOTA
Puede hacer que su entorno de shell use la misma configuración de LANG que su
entorno gráfico, incluso cuando inicia sesión mediante una consola virtual basada
en texto o mediante un ssh. Una manera de hacer esto es colocar un código similar
al siguiente en su archivo ~/.bashrc. Este código de ejemplo definirá el idioma
empleado en un inicio de sesión en una interfaz de texto de modo que coincida con
el idioma actualmente definido en el entorno de escritorio GNOME del usuario:
i=$(grep 'Language=' /var/lib/AccountsService/users/${USER}
| sed 's/Language=//')
if [ "$i" != "" ]; then
export LANG=$i
fi
Es posible que algunos idiomas, como japonés, coreano, chino y otros con un
conjunto de caracteres no latinos, no se vean correctamente en consolas virtuales
basadas en texto.
DO101-OCP4.2-es-1-20191127 xi

Introducción
Se pueden crear comandos individuales para usar otro idioma mediante la configuración de la
variable LANG en la línea de comandos:
[user@host ~]$ LANG=fr_FR.utf8 date
jeu. avril 25 17:55:01 CET 2019
Los comandos subsiguientes se revertirán y usarán el idioma de salida predeterminado del
sistema. El comando locale se puede usar para determinar el valor actual de LANG y otras
variables de entorno relacionadas.
Configuración del método de entrada
GNOME 3 en Red Hat Enterprise Linux 7 o posterior usa de manera automática el sistema de
selección de métodos de entrada IBus, que permite cambiar las distribuciones del teclado y los
métodos de entrada de manera rápida y sencilla.
La aplicación Region & Language también se puede usar para habilitar métodos de entrada
alternativos. En la ventana de la aplicación Region & Language, el cuadro Input Sources
(Fuentes de entrada) muestra los métodos de entrada disponibles en el momento. De forma
predeterminada, es posible que English (US) (Inglés [EE. UU.]) sea el único método
disponible. Resalte English (US) (Inglés [EE. UU.]) y haga clic en el ícono de teclado para ver la
distribución actual del teclado.
Para agregar otro método de entrada, haga clic en el botón + en la parte inferior izquierda de la
ventana Input Sources (Fuentes de entrada). Se abrirá la ventana Add an Input Source
(Agregar una fuente de entrada). Seleccione su idioma y, luego, el método de entrada o la
distribución del teclado de su preferencia.
Cuando haya más de un método de entrada configurado, el usuario puede alternar entre ellos
rápidamente escribiendo Super+Space (en ocasiones denominado)Windows+Space).
También aparecerá un indicador de estado en la barra superior de GNOME con dos
funciones: por un lado, indicar el método de entrada activo; por el otro lado, funcionar como
menú que puede usarse para cambiar de un método de entrada a otro o seleccionar funciones
avanzadas de métodos de entrada más complejos.
Algunos de los métodos están marcados con engranajes, que indican que tienen opciones de
configuración y capacidades avanzadas. Por ejemplo, el método de entrada japonés Japanese
(Kana Kanji) (Japonés [Kana Kanji]) permite al usuario editar previamente texto en latín y usar
las teclas de flecha hacia abajo y flecha hacia arriba para seleccionar los caracteres
correctos que se usarán.
El indicador también puede ser de utilidad para los hablantes de inglés estadounidense. Por
ejemplo, dentro de English (United States) (Inglés [Estados Unidos]) está la configuración
de teclado English (international AltGr dead keys) (Inglés [internacional, teclas
inactivas AltGr]), que trata AltGr (o la tecla Alt derecha) en un teclado de 104/105 teclas de
una PC como tecla modificadora de "Bloq Mayús secundario" y tecla de activación de teclas
inactivas para escribir caracteres adicionales. Hay otras distribuciones alternativas disponibles,
como Dvorak.
xii DO101-OCP4.2-es-1-20191127

Introducción
NOTA
Cualquier carácter Unicode puede ingresarse en el entorno de escritorio GNOME si
conoce el código Unicode del carácter. Escriba Ctrl+Shift (Mayús)+U seguido
del código. Después de ingresar Ctrl+Shift (Mayús)+U, aparecerá una u
subrayada que indicará que el sistema espera la entrada del código Unicode.
Por ejemplo, la letra lambda del alfabeto griego en minúscula tiene el código U
+03BB y puede ingresarse escribiendo Ctrl+Shift (Mayús)+U, luego 03BB y,
por último, Enter (Intro).
VALORES DE IDIOMA PREDETERMINADO EN TODO
EL SISTEMA
El idioma predeterminado del sistema está definido en inglés estadounidense y usa la codificación
UTF-8 de Unicode como conjunto de caracteres (en_US.utf8), pero puede cambiarse durante o
después de la instalación.
Desde la línea de comandos, el usuario root puede cambiar los ajustes de configuración regional
de todo el sistema con el comando localectl. Si localectl se ejecuta sin argumentos,
muestra los ajustes actuales de configuración regional de todo el sistema.
Para configurar el idioma predeterminado de todo el sistema, ejecute el comando localectl
set-locale LANG=locale, donde locale es el valor adecuado para la variable de entorno LANG
de la tabla "Referencia de códigos de idioma" de este capítulo. El cambio se efectuará para los
usuarios la próxima vez que inicien sesión y se almacenará en /etc/locale.conf.
[root@host ~]#
localectl set-locale LANG=fr_FR.utf8
En GNOME, un usuario administrativo puede cambiar esta configuración en Region &
Language (Región e idioma) haciendo clic en el botón Login Screen (Pantalla de inicio de sesión),
ubicado en la esquina superior derecha de la ventana. Si cambia el valor de Language (Idioma) en
la pantalla de inicio de sesión, también se ajustará el valor de idioma predeterminado en todo el
sistema almacenado en el archivo de configuración /etc/locale.conf.
DO101-OCP4.2-es-1-20191127 xiii

Introducción
IMPORTANTE
Las consolas virtuales basadas en texto, como tty4, pueden mostrar una cantidad
más limitada de fuentes que los terminales en una consola virtual que ejecuta un
entorno gráfico o los pseudoterminales para las sesiones de ssh. Por ejemplo, los
caracteres del japonés, coreano y chino posiblemente no se visualicen como se
espera en una consola virtual basada en texto. Por este motivo, debe considerar el
uso del inglés u otro idioma con un conjunto de caracteres latinos para los valores
predeterminados para todo el sistema.
De manera similar, las consolas virtuales basadas en texto admiten una cantidad
limitada de métodos de entrada; esto se administra de manera separada desde
el entorno gráfico de escritorio. La configuración de la entrada global disponible
se puede establecer mediante localectl tanto para las consolas virtuales
basadas en texto como para el entorno gráfico. Consulte las páginas de manual
localectl(1) y vconsole.conf(5) para obtener más información.
PAQUETES DE IDIOMAS
Los paquetes de RPM especiales, llamados langpacks, instalan paquetes de idiomas que
agregan soporte para idiomas específicos. Estos paquetes de idiomas usan dependencias para
instalar automáticamente paquetes de RPM adicionales que contienen localizaciones, diccionarios
y traducciones para otros paquetes de software en su sistema.
Para enumerar los paquetes de idiomas que están instalados y pueden instalarse, use yum list
langpacks-*:
[root@host ~]# yum list langpacks-*
Updating Subscription Management repositories.
Installed Packages
langpacks-en.noarch 1.0-12.el8 @AppStream
Available Packages
langpacks-af.noarch 1.0-12.el8 rhel-8-for-x86_64-appstream-rpms
langpacks-am.noarch 1.0-12.el8 rhel-8-for-x86_64-appstream-rpms
langpacks-ar.noarch 1.0-12.el8 rhel-8-for-x86_64-appstream-rpms
langpacks-as.noarch 1.0-12.el8 rhel-8-for-x86_64-appstream-rpms
langpacks-ast.noarch 1.0-12.el8 rhel-8-for-x86_64-appstream-rpms
...output omitted...
Para agregar soporte de idioma, instale el paquete de idiomas correcto. Por ejemplo, el siguiente
comando agrega soporte para francés:
[root@host ~]#
yum install langpacks-fr
Use yum repoquery --whatsupplements para determinar qué paquetes de RPM pueden
instalarse mediante el paquete de idiomas:
xiv DO101-OCP4.2-es-1-20191127

Introducción
[root@host ~]# yum repoquery --whatsupplements langpacks-fr
Last metadata expiration check: 0:01:33 ago on Wed 06 Feb 2019 10:47:24 AM CST.
glibc-langpack-fr-0:2.28-18.el8.x86_64
gnome-getting-started-docs-fr-0:3.28.2-1.el8.noarch
hunspell-fr-0:6.2-1.el8.noarch
hyphen-fr-0:3.0-1.el8.noarch
libreoffice-langpack-fr-1:6.0.6.1-9.el8.x86_64
man-pages-fr-0:3.70-16.el8.noarch
mythes-fr-0:2.3-10.el8.noarch
IMPORTANTE
Los paquetes de idiomas usan dependencias débiles de RPM para instalar
paquetes complementarios solo cuando el paquete principal que lo necesita
también está instalado.
Por ejemplo, al instalar langpacks-fr como se muestra en las instancias
anteriores, el paquete mythes-fr solo se instalará si el tesauro mythes también
está instalado en el sistema.
Si mythes se instala posteriormente en ese sistema, el paquete mythes-fr
también se instalará automáticamente debido a la dependencia débil del paquete
langpacks-fr ya instalado.
REFERENCIAS
Páginas de manual locale(7), localectl(1), locale.conf(5),
vconsole.conf(5), unicode(7) y utf-8(7).
Conversiones entre los nombres de las distribuciones X11 del entorno de escritorio
gráfico y los nombres en localectl en el archivo/usr/share/X11/xkb/rules/
base.lst.
REFERENCIA DE CÓDIGOS DE IDIOMA
NOTA
Es posible que esta tabla no refleje todos los paquetes de idiomas disponibles en su
sistema. Use yum info langpacks-SUFFIX para obtener más información sobre
un paquete de idiomas en particular.
Códigos de idioma
IDIOMA SUFIJO DE LOS
PAQUETES DE
IDIOMAS
VALOR $LANG
Inglés (EE. UU.) en en_US.utf8
DO101-OCP4.2-es-1-20191127 xv

Introducción
IDIOMA SUFIJO DE LOS
PAQUETES DE
IDIOMAS
VALOR $LANG
Asamés as as_IN.utf8
Bengalí bn bn_IN.utf8
Chino (simplificado) zh_CN zh_CN.utf8
Chino (tradicional) zh_TW zh_TW.utf8
Francés fr fr_FR.utf8
Alemán de de_DE.utf8
Guyaratí Gu gu_IN.utf8
Hindi hi hi_IN.utf8
Italiano it it_IT.utf8
Japonés ja ja_JP.utf8
Canarés kn kn_IN.utf8
Coreano ko ko_KR.utf8
Malabar ml ml_IN.utf8
Maratí mr mr_IN.utf8
Odia or or_IN.utf8
Portugués (Brasil) pt_BR pt_BR.utf8
Punyabí pa pa_IN.utf8
Ruso ru ru_RU.utf8
Español es es_ES.utf8
Tamil ta ta_IN.utf8
Telugú te te_IN.utf8
xvi DO101-OCP4.2-es-1-20191127

CAPÍTULO 1
CONFIGURACIÓN
DE UN ENTORNO DE
DESARROLLADOR DE
APLICACIONES EN LA NUBE
META Configurar un entorno de desarrollador con
un control de versiones y un entorno de
desarrollador modernos e integrados.
OBJETIVOS • Editar el código fuente de la aplicación con
Visual Studio Code (VS Code).
• Crear un nuevo repositorio de Git.
• Usar el control de versiones para administrar
y colaborar con el código fuente de la
aplicación.
SECCIONES • Desarrollo de aplicaciones con Visual Studio
Code (y ejercicio guiado)
• Inicialización de un repositorio de Git (y
ejercicio guiado)
• Administración del código fuente de la
aplicación con Git (y ejercicio guiado)
DO101-OCP4.2-es-1-20191127 1

CAPÍTULO 1 | Configuración de un entorno de desarrollador de aplicaciones en la nube
DESARROLLO DE APLICACIONES CON
VISUAL STUDIO CODE
OBJETIVOS
Tras finalizar esta sección, debe ser capaz de editar el código fuente de la aplicación con Virtual
Studio Code (VS Code).
ENTORNOS DE DESARROLLO INTEGRADOS
Los desarrolladores de software ejecutan muchos tipos diferentes de tareas durante el ciclo de
vida de desarrollo de software de una aplicación:
• Compilan y crean el código fuente.
• Corrigen errores de sintaxis.
• Depuran errores de tiempo de ejecución.
• Mantienen los cambios del control de versiones en el código fuente.
• Refactorizan el código fuente.
• Ejecutan pruebas de código fuente.
En el pasado, los desarrolladores usaban un conjunto de herramientas independientes tales como
editores, compiladores, intérpretes y depuradores para desarrollar aplicaciones de software. Las
ineficiencias surgían del uso de herramientas separadas, lo que derivó en la creación de entornos
de desarrollo integrados o IDE. Los IDE mejoran la productividad del desarrollador mediante la
integración de herramientas de desarrollo de software comunes en una sola aplicación. A menudo,
los IDE integran lo siguiente:
• Editores específicos de un idioma
• Funciones de finalización de código
• Resaltado de la sintaxis
• Documentación del lenguaje de programación
• Depuración del código
• Herramientas de gestión de control de código fuente, como Git, SVN o Mercurial
Muchos IDE modernos admiten varios lenguajes de programación. Mediante el uso de estos
IDE, los desarrolladores crean aplicaciones en una gran variedad de lenguajes diferentes sin
la necesidad de aprender herramientas específicas de los lenguajes, como compiladores e
intérpretes.
DESARROLLO DE SOFTWARE CON VS CODE
VS Code es un conocido IDE de código abierto que admite varios lenguajes, como JavaScript,
Python, Go, C#, TypeScript y más. Brinda capacidades de resaltado de la sintaxis, finalización del
código, depuración y fragmentación del código, junto con un marco de complementos que permite
instalar una funcionalidad adicional desde un catálogo de complementos.
2 DO101-OCP4.2-es-1-20191127

En este curso, usará VS Code para crear, editar y administrar proyectos de código fuente.
Descripción general de la interfaz de VS Code
La interfaz de VS Code contiene cinco componentes primarios:
Barra de actividades. Ubicada en el extremo izquierdo, contiene atajos para cambiar la
vista de la barra lateral. De manera predeterminada, la barra de actividades contiene accesos
directos para las vistas de explorador, búsqueda, control de código fuente, depuración y
extensiones. También puede acceder a estas vistas de actividades desde el menú View (Ver).
Barra lateral. Ubicada inmediatamente a la derecha de la barra de actividades, esta área
muestra la vista de actividad seleccionada, como la vista del explorador.
Grupos de editores. La región superior derecha de VS Code contiene uno o más grupos de
editores.
De manera predeterminada, hay solo un grupo de editores. Cualquier editor activo ocupa
toda la región del grupo de editores.
Haga clic en el ícono de editor dividido a la derecha en la esquina superior derecha
para crear un segundo grupo de editores. Con dos grupos de editores, puede editar dos
archivos diferentes uno al lado del otro.
Paneles. Situados debajo de los editores, los paneles individuales proporcionan
diferente información de salida o depuración para las actividades en VS Code. De forma
predeterminada, se proporcionan cuatro paneles:
• Problemas
• Resultados
• Consola de depuración
• Terminal
Barra de estado. Ubicada en la parte inferior, esta área proporciona información sobre el
proyecto y los archivos abiertos a medida que se editan.
Espacios de trabajo de VS Code
VS Code organiza un conjunto de proyectos de software y valores de configuración relacionados
en un espacio de trabajo. Los datos de configuración de cada espacio de trabajo se almacenan
en un archivo con la extensión .code-workspace.
En el menú File (Archivo), puede cerrar, guardar y abrir un espacio de trabajo.
DO101-OCP4.2-es-1-20191127 3

Por ejemplo, considere la aplicación web denominada myapp con los siguientes componentes:
• Código JavaScript para la interfaz de usuario frontal de la aplicación.
• Código Python para la lógica interna de la aplicación.
• Configuración y secuencia de comandos para la base de datos de la aplicación.
• Archivos AsciiDoc para la documentación de la aplicación.
Si mantiene cada uno de estos componentes en carpetas o repositorios de código separados,
puede agregar cada carpeta a un espacio de trabajo myapp de VS Code dedicado a la aplicación:
Figura 1.1: Espacio de trabajo de VS Code con varias carpetas de código fuente
Para agregar una carpeta de código fuente a un espacio de trabajo, haga clic en File (Archivo) →
Add Folder to Workspace... (Agregar carpeta al espacio de trabajo...).
Para eliminar una carpeta de código fuente de un espacio de trabajo, acceda a la vista del
explorador (View (Ver) → Explorer (Explorador)). Haga clic con el botón secundario del ratón en
una carpeta del espacio de trabajo de nivel superior seleccionada y elija Remove Folder from
Workspace (Eliminar carpeta del espacio de trabajo) para eliminar la carpeta del espacio de
trabajo.
Terminal integrado de VS Code
Si bien VS Code integra muchas herramientas de desarrollo, es posible que necesite acceder a
herramientas o aplicaciones de desarrollo externas. VS Code integra el terminal desde su sistema
operativo, lo que permite ejecutar comandos de terminal arbitrarios en VS Code. Para ver el
terminal integrado, haga clic en View (Ver) → Terminal.
Puede abrir varios terminales en el panel de terminales de VS Code. El panel de terminales
contiene una lista de terminales abiertos. Para mostrar un terminal, selecciónelo de la lista. Para
cerrar un terminal, haga clic en Kill Terminal (Eliminar terminal).
4 DO101-OCP4.2-es-1-20191127

Figura 1.2: Terminal integrado de VS Code
Extensiones de VS Code
Si bien el terminal integrado de VS Code ayuda a ejecutar los comandos arbitrarios, debe instalar
y aprender a usar los comandos externos necesarios. Además, los comandos del terminal no
aprovechan los patrones de uso comunes en VS Code.
VS Code proporciona un marco de extensión para fomentar la integración de las funciones de
desarrollo de software en VS Code. Cualquier usuario u organización puede contribuir a las
extensiones de VS Code. Después de que se desarrolla una extensión, se anuncia y publica en el
mercado de VS Code.
Puede buscar, descargar e instalar extensiones desde el mercado de VS Code en VS Code. Haga
clic en View (Ver) → Extensions (Extensiones) para acceder a la vista de extensiones en la barra
lateral.
NOTA
En este curso, no instalará ninguna extensión adicional para VS Code.
DESARROLLO DE LA APLICACIÓN NODE.JS CON VS
CODE
Muchas de las aplicaciones web de ejemplo en los ejercicios del curso son aplicaciones Node.js. Si
un ejercicio de este curso requiere que edite el código, use VS Code para realizar los cambios.
Node.js es un motor de tiempo de ejecución de código abierto que ejecuta JavaScript fuera del
navegador. Está diseñado para gestionar de forma eficiente muchas conexiones simultáneas para
aplicaciones de red. Además, Node.js permite escribir códigos visibles y ocultos en un lenguaje:
JavaScript. Por estas razones, Node.js es un motor de tiempo de ejecución popular para el
desarrollo de aplicaciones web.
Instalación de Node.js
Para instalar Node.js, diríjase a https://nodejs.org/en/download en un navegador. Haga clic en el
enlace adecuado para su sistema operativo y, luego, siga las instrucciones.
Después de instalar Node.js, use el comando node para ejecutar las aplicaciones Node.js.
Módulos Node.js
Todos los lenguajes de programación modernos admiten la reutilización del código a través de
bibliotecas, paquetes y módulos compartidos.
DO101-OCP4.2-es-1-20191127 5

Los módulos son la unidad más pequeña de código reutilizable en Node.js. Node.js tiene varios
módulos incorporados. Además, puede descargar y usar módulos Node.js de terceros.
Cuando crea una aplicación Node.js compleja, escribe módulos Node.js personalizados para
agrupar el código lógico relacionado. Los módulos Node.js personalizados se definen en archivos
de texto JavaScript.
Use la palabra clave require para cargar un módulo Node.js. Considere el siguiente ejemplo:
var http = require('http');
var mymodule = require('./mymodule');
La variable http contiene una referencia al módulo http incorporado, mientras que la variable
mymodule contiene una referencia al módulo definido en el archivo mymodule.js.
Paquetes Node.js
Al igual que otros lenguajes de programación, Node.js proporciona una manera de definir y
administrar las dependencias de las aplicaciones. Una dependencia de la aplicación Node.js se
denomina paquete. Un paquete es una recopilación de uno o más módulos Node.js, o un código
de aplicación, que se descarga desde el repositorio de paquetes Node.js.
Las dependencias de la aplicación se definen en el archivo packages.json, ubicado en la
raíz de la carpeta del proyecto Node.js. A continuación, se incluye un ejemplo de un archivo
packages.json:
{
"name": "hello",
"version": "0.1.0",
"description": "An example package.json",
"author": "Student <student@example.com [mailto:student@example.com]>",
scripts: {
"start": "node app.js"
},
"dependencies": {
"cookie-parser": "1.4.*",
"http-errors": ">=1.6.3",
},
"license": "MIT"
}
En este ejemplo, la aplicación hello requiere versiones específicas de los paquetes cookie-
parser y http-errors.
El archivo packages.json también define otros metadatos para la aplicación Node.js, como el
nombre, la versión y el autor de la aplicación.
Administrador de paquetes de nodos
El administrador de paquetes de nodos (NPM) es una herramienta de línea de comandos que se
usa para crear, instalar y publicar paquetes Node.js. Para la mayoría de los sistemas operativos, el
comando npm (abreviatura de "administrador de paquetes de nodos") se instala como parte del
proceso de instalación de Node.js.
Para instalar las dependencias para la aplicación Node.js, use el comando npm install.
6 DO101-OCP4.2-es-1-20191127

Para inicializar un directorio vacío como proyecto Node.js, use el comando npm init para crear
un archivo packages.json para una nueva aplicación Node.js.
Para administrar el ciclo de vida de la aplicación, use el comando npm para iniciar, detener o
reiniciar la aplicación.
Marco de la aplicación web Express
Express es un marco Node.js común que tiene como objetivo simplificar la creación de servicios
web. Debido a que Express es un paquete Node.js, use el comando npm install para instalar
Express:
$> npm install express
Después de instalar el paquete Node.js Express, el comando express está disponible en su
sistema. Use el comando express para crear un conjunto de archivos de proyectos iniciales para
una nueva aplicación Express.
Considere el siguiente ejemplo:
$> express /path/to/project/folder/myapp
El comando crea una carpeta myapp que contiene un archivo packages.json:
{
"name": "myapp",
"version": "0.0.0",
"private": true,
"scripts": {
"start": "node ./bin/www"
},
"dependencies": {
"cookie-parser": "~1.4.4",
"debug": "~2.6.9",
"express": "~4.16.1",
"http-errors": "~1.6.3",
"jade": "~1.11.0",
"morgan": "~1.9.1"
}
}
El paquete Express es una dependencia para la aplicación myapp de Node.js. Inicie la aplicación
myapp con el comando node ./bin/www.
El código fuente en el archivo ./bin/www carga el módulo app de Node.js:
/**
* Module dependencies.
*/
var app = require('../app');
DO101-OCP4.2-es-1-20191127 7

El código fuente del módulo app se encuentra en el archivo app.js, ubicado en la raíz del
directorio del proyecto myapp. El archivo app.js contiene la lógica de la aplicación principal.
El archivo app.js para la aplicación Express simple "Hello, World!" contiene lo siguiente:
var express = require('express');
var app = express();
app.get('/', function (req, res) {
res.send('Hello, World!n');
});
app.listen(8080, function () {
console.log('Example app listening on port 8080!');
});
module.exports = app;
La variable app hace referencia a una instancia de la aplicación Express. La aplicación está
configurada para escuchar las solicitudes en el puerto 8080. Cuando accede al terminal de la
aplicación, las aplicaciones envían la respuesta Hello, World!.
REFERENCIAS
Entornos de desarrollo integrados: Wikipedia
https://en.wikipedia.org/wiki/Integrated_development_environment
Para obtener más información sobre los espacios de trabajo y las carpetas de
proyectos de Visual Studio Code, consulte la documentación de Visual Studio Code
en
https://code.visualstudio.com/docs/editor/multi-root-workspaces
Para obtener más información sobre el terminal integrado de Visual Studio Code,
consulte la documentación de Visual Studio Code en
https://code.visualstudio.com/docs/editor/integrated-terminal
Para obtener más información acerca de los módulos Node.js, consulte la
documentación de Node.js en
https://nodejs.org/api/modules.html#modules_modules
8 DO101-OCP4.2-es-1-20191127

EJERCICIO GUIADO
DESARROLLO DE APLICACIONES CON
VISUAL STUDIO CODE
En este ejercicio, usará Visual Studio Code (VS Code) para crear una aplicación Node.js
simple.
RESULTADOS
Deberá ser capaz de realizar lo siguiente:
• Descargar e instalar Node.js.
• Descargar e instalar VS Code.
• Crear un espacio de trabajo en VS Code.
• Agregar una carpeta de proyectos a un espacio de trabajo de VS Code.
ANDES DE COMENZAR
Para realizar este ejercicio, asegúrese de tener acceso a un sistema Linux (basado en Fedora
o Debian), macOS o Windows, incluidos los permisos necesarios para instalar software en
dicho sistema.
1. Descargue e instale Node.js.
1.1. Instalación en Windows.
• En un navegador, vaya a https://nodejs.org/en/download. Haga clic en Windows
Installer para descargar el instalador de Node.js para Windows. Haga clic en
Save File (Guardar archivo) para iniciar una ventana de archivo. Haga clic en
Save (Guardar) en la ventana de archivo para aceptar el nombre de archivo
predeterminado y la ubicación para el archivo.
• Navegue hasta el archivo descargado y ábralo para ver la ventana del asistente
de configuración. Haga clic en Next (Siguiente) en la pantalla de bienvenida para
comenzar la instalación.
• Marque I accept the terms in the License Agreement (Acepto los
términos del Acuerdo de licencia) y haga clic en Next (Siguiente).
• Haga clic en Next (Siguiente) para aceptar la ubicación de instalación
predeterminada.
• Haga clic en Next (Siguiente) para aceptar los valores predeterminados en la
pantalla Custom Setup (Configuración personalizada).
• Haga clic en Next (Siguiente) para omitir la instalación de las herramientas que debe
usar para compilar los módulos nativos.
DO101-OCP4.2-es-1-20191127 9

• Haga clic en Install (Instalar) para comenzar la instalación. Haga clic en Yes (Sí)
para permitir que la aplicación realice cambios en su sistema. Espere que finalice la
instalación.
• Haga clic en Finish (Finalizar) para salir del asistente de configuración.
1.2. Instalación en Linux.
• Abra un nuevo terminal de línea de comandos.
• Para instalar Node.js en los sistemas Ubuntu y Debian, use el siguiente comando:
yourname@yourhost:~$ sudo apt install nodejs
El comando puede solicitar su contraseña para instalar el paquete.
Un ejercicio posterior requiere el administrador de paquetes de nodos (NPM).
Instale el paquete:
yourname@yourhost:~$ sudo apt install npm
El paquete npm de Ubuntu instala varios paquetes de desarrollo de software
diferentes. Puede omitir esta instalación de npm si necesita minimizar la cantidad de
paquetes en su sistema Ubuntu.
• Para instalar Node.js en los sistemas Fedora y Red Hat Enterprise Linux 8, use el
siguiente comando:
[yourname@yourhost ~]$ sudo dnf install nodejs
1.3. Instalación en macOS.
• Diríjase a https://nodejs.org/en/download/ en el navegador web.
• Descargue el instalador estable de Node.js de soporte a largo plazo (LTS) de 64 bits
(.pkg) para macOS.
• Ejecute el instalador .pkg. En versiones recientes de macOS (10.14 y posterior), el
software que se instala desde fuentes distintas a App Store se bloquea de manera
predeterminada.
Abra System Preferences (Preferencias del sistema) → Security & Privacy
(Seguridad y privacidad) y, en la pestaña General, haga clic en Open anyway
(Abrir de todos modos) para continuar. Vuelva a ejecutar el instalador de Node.js si
es necesario.
• Haga clic en Continue (Continuar). El instalador instalará el nodo, el tiempo de
ejecución de Node.js y npm, el administrador de paquetes Node.js, en /usr/local/
bin.
• Haga clic en Continue (Continuar) en la ventana Software License
Agreement (Acuerdo de licencia de software).
10 DO101-OCP4.2-es-1-20191127

• Haga clic en Agree (Aceptar) para aceptar los términos de la licencia.
• Por último, haga clic en Install (Instalar) para iniciar la instalación. Es posible
que se le solicite la contraseña de macOS. Ingrese su contraseña de macOS para
continuar.
2. Descargue e instale VS Code.
ADVERTENCIA
Este curso está diseñado para VS Code versión v1.39, pero las instrucciones que
siguen muestran cómo instalar la versión más reciente de VS Code.
Si desea hacer coincidir la versión de VS Code en este curso, vaya a https://
code.visualstudio.com/updates/v1_39 y siga las instrucciones de instalación para su
sistema operativo.
2.1. Instalación en Windows.
• En un navegador de su sistema Windows, diríjase a https://code.visualstudio.com/
download.
• Haga clic en Windows para descargar VS Code para Windows.
• Haga clic en Save File (Guardar archivo) para guardar el archivo. En la ventana
que aparece, haga clic en Save (Guardar) para aceptar el nombre de archivo y la
ubicación de descarga predeterminados.
• Navegue hasta el archivo descargado y ábralo para ver el asistente de configuración
de VS Code. Seleccione I accept the agreement (Acepto el acuerdo) y, luego,
haga clic en Next (Siguiente).
• Haga clic en Next (Siguiente) para aceptar la ubicación predeterminada para la
instalación. Si la carpeta ya existe, haga clic en Yes (Sí) para instalarla en la carpeta
de todas maneras.
• Haga clic en Next (Siguiente) para agregar una carpeta de menú de inicio para VS
Code. Si no necesita una carpeta de menú de inicio para VS Code, seleccione Don’t
create a Start Menu folder (No crear una carpeta de menú de inicio) antes
de hacer clic en Next (Siguiente).
• Revise la lista de tareas adicionales que se deben realizar durante la instalación de
VS Code. Seleccione las tareas que necesita para su sistema y, luego, haga clic en
Next (Siguiente).
• Haga clic en Install (Instalar) para instalar VS Code.
• Haga clic en Finish (Finalizar) para cerrar el asistente de configuración.
2.2. Instalación en Linux.
• En un navegador, diríjase a https://code.visualstudio.com/download.
• Para los sistemas Ubuntu y Debian, haga clic en .deb. Para los sistemas Fedora y
Red Hat Enterprise Linux, haga clic en .rpm.
DO101-OCP4.2-es-1-20191127 11

• Seleccione Open with (Abrir con) y, luego, seleccione Software Install
(default) (Instalación de software) (predeterminada). Haga clic en OK (Aceptar).
• En la ventana de instalación, haga clic en Install (Instalar).
• En la ventana Authentication Required (Autenticación requerida), ingrese su
contraseña y haga clic en Authenticate (Autenticar).
• Cuando se complete la instalación, cierre la ventana.
2.3. Instalación en macOS.
• Diríjase a https://code.visualstudio.com/download en el navegador web.
• Haga clic en el ícono de Apple (Mac) para descargar el archivo zip de Visual Studio
Code.
• Descomprima el archivo zip y, luego, copie el binario ejecutable de Visual Studio
Code en la carpeta Applications (Aplicaciones) con el buscador de macOS.
• Haga doble clic en el binario de Visual Studio Code para iniciar Visual Studio
Code.
3. Abra VS Code y cree un espacio de trabajo para alojar sus proyectos.
3.1. Abra la aplicación VS Code de acuerdo con su sistema operativo. Haga clic en View
(Ver) → Explorer (Explorador) para ver la vista del explorador.
3.2. Si instaló y utilizó VS Code en su sistema antes de este curso, haga clic en File
(Archivo) → Close Workspace (Cerrar espacio de trabajo). Si File (Archivo) → Close
Workspace (Cerrar espacio de trabajo) no está disponible, omita este paso.
Figura 1.3: Aplicación VS Code
3.3. Haga clic en File (Archivo) → Save Workspace As... (Guardar espacio de trabajo
como...). En la ventana que aparece, diríjase a su directorio de inicio. Escriba My
Projects como nombre de archivo y, luego, haga clic en Save (Guardar). La vista del
explorador muestra el botón Add Folder (Agregar carpeta) para añadir carpetas de
proyectos a su espacio de trabajo.
12 DO101-OCP4.2-es-1-20191127

Figura 1.4: Espacio de trabajo de VS Code
4. Cree una carpeta de proyecto hello-nodejs y, luego, agréguela a su espacio de trabajo.
4.1. En VS Code, haga clic en File (Archivo) → Add Folder to Workspace... (Agregar carpeta
al espacio de trabajo...). En la ventana que aparece, diríjase a su directorio de inicio.
Cree una nueva carpeta con el nombre hello-nodejs. Haga clic en Add (Agregar)
para añadir esta nueva carpeta a su espacio de trabajo.
Figura 1.5: Adición de una carpeta de proyectos a un espacio de trabajo de VS Code
5. Cree un archivo app.js en el proyecto. Guarde el archivo con el siguiente contenido:
console.log("Hello World!n");
5.1. Haga clic con el botón secundario del ratón en hello-nodejs en el espacio de
trabajo y, luego, seleccione New File (Nuevo archivo). Ingrese app.js para el
nombre del archivo a fin de iniciar una pestaña VS Code para el nuevo archivo.
5.2. Agregue el texto console.log("Hello World!n"); a la pestaña del editor
app.js y, luego, guarde el archivo (File (Archivo) → Save (Guardar)).
6. Haga clic con el botón secundario del ratón en hello-nodejs en el espacio de trabajo
y, luego, seleccione Open in Terminal (Abrir en el terminal) para acceder al proyecto
hello-nodejs desde el terminal integrado de VS Code.
DO101-OCP4.2-es-1-20191127 13

Figura 1.6: Apertura de una carpeta de proyecto en el terminal integrado de VS Code
7. En el terminal integrado, ejecute el nodo app.js para probar su código de muestra y su
instalación de Node.js.
Figura 1.7: Ejecución de la aplicación Node.js en el terminal de VS Code
8. Para eliminar su trabajo, haga clic en el ícono Kill Terminal (Eliminar terminal) para cerrar la
ventana del terminal integrado.
Figura 1.8: Cierre de la ventana del terminal integrado en VS Code
Esto concluye el ejercicio guiado.
14 DO101-OCP4.2-es-1-20191127

INICIALIZACIÓN DE UN REPOSITORIO
DE GIT
OBJETIVOS
Tras finalizar esta sección, deberá ser capaz de crear un repositorio de Git.
CONTROL DE LA VERSIÓN DE SOFTWARE
Un sistema de control de versiones (VCS) permite gestionar y colaborar de forma eficiente con
otros respecto de los cambios de código. Los sistemas de control de versiones proporcionan
muchas ventajas, entre las que se incluyen:
• La capacidad de revisar y restaurar las versiones anteriores de los archivos.
• La capacidad de comparar dos versiones del mismo archivo para identificar los cambios.
• Un registro o archivo de quién realizó cambios en un momento determinado.
• Mecanismos para que varios usuarios modifiquen archivos de forma colaborativa, resuelvan
cambios conflictivos y combinen cambios conjuntos.
Hay varios sistemas de control de versiones de código abierto disponibles, entre los que se
incluyen:
• CVS
• SVN
• Git
• Mercurial
INTRODUCCIÓN A GIT
Git es el sistema de control de versiones que se usa con más frecuencia. Por este motivo, se utiliza
Git como sistema de control de versiones para todos los ejercicios de este curso.
Git puede convertir cualquier carpeta del sistema local en un repositorio de Git. Aunque tiene
muchas de las ventajas del control de versiones, el repositorio de Git solo existe en su sistema
local.
Para compartir su repositorio con otro colaborador, debe alojar el repositorio en una plataforma de
repositorio de códigos.
Existen muchas plataformas de repositorio de códigos gratuitas, entre las que se incluyen:
• GitHub
• GitLab
• BitBucket
• SourceForge
DO101-OCP4.2-es-1-20191127 15

En este curso, utilizará GitHub para alojar y compartir sus repositorios de Git.
Descripción general del flujo de trabajo de Git
Para recuperar los archivos de proyectos para un proyecto de software existente con Git, clone el
repositorio de Git para el proyecto.
Cuando clona un proyecto, se crea una copia completa del repositorio remoto original en el
sistema de forma local. Su copia local del repositorio contiene el historial completo de los archivos
de proyectos, no solo la última versión de los archivos de proyectos. Puede cambiar a diferentes
versiones de la aplicación o comparar dos versiones diferentes de un archivo sin conectarse al
repositorio remoto. Esto le permite continuar implementando cambios en el código cuando el
repositorio remoto no está disponible.
Git no sincroniza automáticamente los cambios locales de repositorios en el repositorio remoto ni
descarga automáticamente los nuevos cambios remotos en su copia local del repositorio. Usted
controla cuándo se confirman las descargas de Git desde el repositorio remoto y cuándo se cargan
las confirmaciones locales en el repositorio remoto. Git proporciona varios mecanismos para
sincronizar de manera segura sus repositorios locales con el repositorio del proyecto remoto.
Para realizar un seguimiento de los cambios de archivos en Git, se crea una serie de instantáneas
(snapshots) de proyectos a medida que se realizan cambios en el proyecto. Cada instantánea
(snapshot) se denomina confirmación. Cuando confirma los cambios en el código de su
repositorio, crea una nueva instantánea (snapshot) de código en su repositorio de Git.
Cada confirmación contiene metadatos que le ayudarán a encontrar y cargar esta instantánea
(snapshot) en un momento posterior:
• Mensaje de confirmación: un resumen de alto nivel de los cambios en el archivo en la
confirmación.
• Marca de hora: la fecha y hora en que se creó la confirmación.
• Autor: un campo que describe quién creó la confirmación.
• Hash de confirmación: un identificador único para la confirmación. Un hash de confirmación
consta de 40 números hexadecimales. Si un comando de Git requiere un hash de confirmación
para realizar una operación, puede abreviar la confirmación a siete caracteres.
Después de crear confirmaciones en un repositorio local en su sistema, debe enviar los cambios
al repositorio remoto. Cuando envía los cambios a un repositorio remoto de Git, carga las
confirmaciones locales en el repositorio remoto. Después del envío, las confirmaciones están
disponibles para que otras personas las descarguen.
Cuando otros contribuyentes envían confirmaciones a un repositorio remoto, dichas
confirmaciones no están presentes en su repositorio local. Para descargar nuevas confirmaciones
de otros colaboradores, extraiga los cambios del repositorio remoto de Git.
Instalación de Git
Git es un sistema de control de versiones de código abierto disponible para sistemas Linux,
macOS y Windows. Antes de poder usar Git, debe instalarlo.
En un navegador, diríjase a https://git-scm.com/downloads y siga las instrucciones para su sistema
operativo.
Después de instalar Git en su sistema, puede usar VS Code para administrar los repositorios de
código fuente de Git.
16 DO101-OCP4.2-es-1-20191127

Para probar su instalación de Git, abra VS Code y acceda al terminal integrado (View (Ver) →
Terminal). En el intérprete de comandos del terminal, ejecute git --version. Si Git se instala
correctamente, se imprime un número de versión en el terminal:
Figura 1.9: Prueba de la instalación de Git en VS Code
Configuración de la vista de control de código fuente en VS
Code
Use la paleta de comandos de VS Code (View (Ver) → Command Palette... (Paleta de
comandos...)) y la vista de control de código fuente (View (Ver) → SCM) para ejecutar
operaciones de Git, como la clonación de un repositorio o la confirmación de cambios en el
código.
De manera predeterminada, la vista de control de código fuente de VS Code es diferente cuando
tiene un repositorio de Git en su espacio de trabajo respecto de cuando tiene varios repositorios
de Git en su espacio de trabajo.
Cuando tiene varios repositorios de Git en su espacio de trabajo, la vista de control de código
fuente muestra la lista SOURCE CONTROL PROVIDERS (PROVEEDORES DE CONTROL DE
CÓDIGO FUENTE):
Figura 1.10: Lista de proveedores de control de código
fuente en la vista de control de código fuente de VS Code.
De manera predeterminada, cuando tiene solo un repositorio de Git en su espacio de trabajo,
la vista de control de código fuente no muestra la lista SOURCE CONTROL PROVIDERS
(PROVEEDORES DE CONTROL DE CÓDIGO FUENTE):
DO101-OCP4.2-es-1-20191127 17

Figura 1.11: Vista de control de código fuente para un solo repositorio de Git.
Para una interfaz de usuario uniforme, independientemente del número de repositorios de Git
de su espacio de trabajo, debe habilitar la opción de administración de control de código fuente
Always Show Providers (Mostrar siempre los proveedores).
Para habilitar esta opción, acceda a la paleta de comandos (View (Ver) → Command Palette...
(Paleta de comandos...)) y escriba settings. Seleccione Preferences: Open Settings
(UI) (Preferencias: abrir configuración [IU]) de la lista de opciones. VS Code muestra una
ventana de configuración:
Figura 1.12: Ventana de configuración para VS Code.
Haga clic en User (Usuario) y, a continuación, haga clic en Features (Funciones) → SCM. VS Code
muestra las opciones de gestión de control de código fuente (SCM) para VS Code. Seleccione
Always Show Providers (Mostrar siempre los proveedores).
18 DO101-OCP4.2-es-1-20191127

Figura 1.13: Opción para ver siempre la lista de proveedores de control
de código fuente en la vista de control de código fuente de VS Code.
Cuando habilita esta opción, VS Code muestra la lista SOURCE CONTROL PROVIDERS
(PROVEEDORES DE CONTROL DE CÓDIGO FUENTE) en la vista de control de código fuente
para cualquier número de repositorios de Git del espacio de trabajo, incluso un solo repositorio.
Clonación del repositorio de Git
Use la paleta de comandos de VS Code (View (Ver) → Command Palette... (Paleta de
comandos...)) y la vista de control de código fuente (View (Ver) → SCM) para ejecutar
operaciones de Git, como la clonación de un repositorio o la confirmación de cambios en el
código.
Para clonar un repositorio de Git remoto en VS Code, acceda a la paleta de comandos (View (Ver)
→ Command Palette... (Paleta de comandos...)). Escriba clone en la petición y, luego, seleccione
Git: Clone (Git: clonar) de la lista de opciones.
Figura 1.14: Uso de la paleta de comandos para clonar un repositorio.
VS Code solicita la URL del repositorio remoto y, luego, solicita la ubicación deseada del
repositorio local en su sistema de archivos.
DO101-OCP4.2-es-1-20191127 19

Después de que VS Code clone el repositorio, agregue la carpeta de repositorio clonada a su
espacio de trabajo de VS Code.
Confirmación de cambios de códigos
Después de agregar un repositorio clonado a su espacio de trabajo de VS Code, puede editar
archivos de proyectos como cualquier otro archivo de área de trabajo. A medida que edita los
archivos de proyectos, Git asigna un estado a cada archivo:
• Modificado: el archivo contiene diferencias guardadas respecto de la versión más reciente. Los
archivos modificados no se agregan ni confirman automáticamente en su repositorio de Git.
• En preparación: un archivo en preparación es un archivo modificado que se marca para que se
incluya como parte de su siguiente confirmación de código en el repositorio.
Cuando confirma el código para el repositorio, solo se incluyen aquellos archivos con el estado
En preparación en la confirmación. Si su proyecto contiene archivos modificados que no están
preparados, entonces esos archivos no se incluyen en la confirmación. Esta función permite
controlar los cambios en los archivos que se incluyen en cada confirmación.
En VS Code, la vista de control de código fuente (View (Ver) → SCM) muestra todos los archivos
de repositorio que se han modificado y preparado. Después de guardar las ediciones en un
archivo, el nombre del archivo aparece en la lista CHANGES (CAMBIOS).
Para agregar un archivo modificado a su siguiente confirmación de código, haga clic en el archivo
modificado en la lista CHANGES (CAMBIOS) en la vista de control de código fuente. VS Code
muestra una nueva pestaña para resaltar los cambios en el archivo:
Figura 1.15: Revisión de los cambios del archivo antes de prepararlo.
Si los cambios en el archivo son exactos y están completos, haga clic en Stage Changes (Preparar
cambios) para agregar los cambios del archivo en la siguiente confirmación de código.
Una vez que se hayan preparado todos los cambios de los archivos deseados, proporcione un
mensaje de confirmación en la vista de control de código fuente. A continuación, seleccione
la casilla de verificación para confirmar todos los cambios del archivo en preparación en su
repositorio local.
Figura 1.16: Confirmación de los archivos en preparación en VS Code.
20 DO101-OCP4.2-es-1-20191127

Uso de un repositorio remoto
Cuando confirme los cambios en los códigos, solo confirmará el código para su repositorio local.
No se realizan cambios en el repositorio remoto.
Cuando esté listo para compartir su trabajo, sincronice su repositorio local con el repositorio
remoto. Para recuperar las confirmaciones del repositorio remoto, Git realiza una operación de
extracción. Para publicar las confirmaciones locales en el repositorio remoto, Git realiza una
operación de envío. VS Code gestiona las operaciones de extracción y envío de Git cuando
sincroniza su repositorio local con el repositorio remoto.
La vista de control de código fuente compara su repositorio local con el repositorio remoto
correspondiente. Si hay confirmaciones para descargar del repositorio remoto, la cantidad de
confirmaciones se muestra con un ícono de flecha de descarga. Si hay confirmaciones locales que
no ha publicado en el repositorio remoto, la cantidad de confirmaciones aparece junto a un ícono
de flecha de carga.
En la siguiente figura no hay ninguna confirmación para descargar y hay una confirmación para
cargar en el repositorio remoto:
Figura 1.17: Estado de repositorio de Git en la vista de control de código fuente y la barra de estado
Haga clic en Syncrhonize Changes (Sincronizar cambios) para publicar sus confirmaciones de
códigos locales en el repositorio remoto. De manera alternativa, puede hacer clic en el mismo
ícono en la barra de estado para publicar las confirmaciones de códigos.
DO101-OCP4.2-es-1-20191127 21

IMPORTANTE
Si la vista de control de código fuente (View (Ver) → SCM) no contiene el
encabezado SOURCE CONTROL PROVIDERS (PROVEEDORES DE CONTROL DE
CÓDIGO FUENTE), no verá el ícono Synchronize Changes (Sincronizar cambios).
Para habilitarlo, haga clic con el botón secundario del ratón en SOURCE CONTROL:
GIT (CONTROL DE CÓDIGO FUENTE: GIT). Si no se muestra una marca de
verificación a la izquierda de Source Control Providers (Proveedores
de control de código fuente), haga clic en Source Control Providers
(Proveedores de control de código fuente).
Figura 1.18: Habilitación de la lista de proveedores de control de código fuente.
Inicialización de un nuevo repositorio de Git
Si tiene un proyecto de software existente que necesita control de versiones, puede convertirlo en
un repositorio de Git.
Para convertir cualquier carpeta de sistema de archivos en un repositorio de Git, acceda a la paleta
de comandos de VS Code (View (Ver) → Command Palette... (Paleta de comandos...)). Escriba
intialize en la petición y, luego, seleccione Git: Initialize Repository (Git: inicializar
repositorio) de la lista de opciones.
VS Code muestra una lista de carpetas de proyectos en el espacio de trabajo.
Figura 1.19: Uso de VS Code para inicializar un repositorio de Git.
22 DO101-OCP4.2-es-1-20191127

Después de seleccionar una carpeta de proyecto, Git inicializa la carpeta como repositorio de Git
vacío. La vista de control de código fuente muestra una entrada para el nuevo repositorio. Debido
a que la carpeta se inicializa como un repositorio vacío, cada archivo en la carpeta de proyecto se
marca como archivo no rastreado.
Figura 1.20: Archivos no rastreados en un repositorio de Git.
Para cualquier archivo de proyecto que requiera control de versiones, haga clic en el ícono de
signo más para agregar el archivo al repositorio local. Cada archivo agregado se muestra en la
lista STAGED CHANGES (CAMBIOS EN PREPARACIÓN) en la vista de control de código fuente.
Después de preparar todos los archivos de proyectos, proporcione un mensaje de confirmación
y, luego, haga clic en el ícono de marca de verificación para crear la primera confirmación en el
repositorio.
Cuando crea un nuevo repositorio desde una carpeta del sistema de archivos local, el nuevo
repositorio no está asociado a un repositorio remoto. Si necesita compartir su repositorio:
1. Cree un nuevo repositorio de Git en una plataforma de alojamiento de códigos, como GitHub.
2. Asocie su repositorio local al nuevo repositorio remoto y, luego, sincronice los cambios.
Adición de un repositorio remoto a un repositorio local
Después de crear un repositorio nuevo en una plataforma de alojamiento de códigos, la plataforma
proporciona una URL de HTTPS y SSH para acceder al repositorio. Use esta URL para agregar el
repositorio alojado como repositorio remoto para su repositorio local.
NOTA
En este curso, solo usará URL de HTTPS para acceder a los repositorios de códigos
remotos. El acceso HTTPS a un repositorio de Git requiere muy poca configuración
adicional, pero requiere que proporcione credenciales para la plataforma de
alojamiento de códigos.
Puede configurar su instalación de Git para almacenar en caché sus credenciales.
Esto ayuda a minimizar las credenciales de reingreso cada vez que se conecta al
repositorio remoto.
El acceso SSH a un repositorio de Git requiere la configuración de las claves de SSH
para la plataforma de alojamiento de códigos.
La configuración de las claves de SSH está más allá del alcance de este curso.
Acceda a la paleta de comandos de VS Code para agregar un repositorio remoto a su repositorio
local. Escriba add remote en la petición y, luego, seleccione Git: Add Remote (Git: agregar
repositorio remoto) de la lista de opciones. Si se le solicita que seleccione un repositorio local,
realice una selección adecuada.
DO101-OCP4.2-es-1-20191127 23

Cuando se le indique, ingrese origin para el nombre remoto; origin es el nombre convencional
que se asigna al repositorio remoto designado como repositorio de códigos central.
En el intérprete de comandos, ingrese la URL de HTTPS para su repositorio remoto. Si tiene
confirmaciones en su repositorio local, aparecerá el ícono Publish Changes (Publicar cambios)
en la lista SOURCE CONTROL PROVIDERS (PROVEEDORES DE CONTROL DE CÓDIGO
FUENTE).
Figura 1.21: Publicación de un repositorio de Git local en un repositorio remoto
Haga clic en el ícono Publish Changes (Publicar cambios) para enviar sus confirmaciones
locales al repositorio remoto. Si se le solicita, proporcione las credenciales necesarias del
repositorio remoto.
REFERENCIAS
Para obtener más información sobre la instalación de Git, consulte la
documentación de Git en
https://git-scm.com/book/en/v2/Getting-Started-Installing-Git
Aspectos básicos de Git
https://git-scm.com/book/en/v2/Git-Basics-Getting-a-Git-Repository
Para obtener más información sobre el uso de Git y el control de versiones en VS
Code, consulte la documentación de VS Code en
https://code.visualstudio.com/docs/editor/versioncontrol
24 DO101-OCP4.2-es-1-20191127

EJERCICIO GUIADO
INICIALIZACIÓN DE UN REPOSITORIO
DE GIT
En este ejercicio, usará VS Code para enviar el código fuente del proyecto a un repositorio
remoto de Git.
RESULTADOS
Deberá ser capaz de realizar lo siguiente:
• Instalar Git.
• Inicializar una carpeta local como repositorio de Git.
• Preparar un archivo en un repositorio de Git.
• Confirmar los archivos en preparación en el repositorio local de Git.
• Enviar confirmaciones del repositorio local de Git al repositorio remoto.
ANDES DE COMENZAR
• Debe tener acceso a un sistema Linux (basado en Fedora o Debian), macOS o Windows y
los permisos necesarios para instalar software en dicho sistema.
• Visual Studio Code (VS Code) debe estar instalado en su sistema.
1. Descargue e instale Git.
• Instalación en Linux.
• Abra un nuevo terminal de línea de comandos.
• Para instalar Git en los sistemas Ubuntu y Debian, use el siguiente comando:
yourname@yourhost:~$ sudo apt install git
• Para instalar Git en los sistemas Fedora y Red Hat Enterprise Linux 8, use el
siguiente comando:
[yourname@yourhost ~]$ sudo dnf install git
• Instalación en macOS.
DO101-OCP4.2-es-1-20191127 25

• Git se instala de manera predeterminada en las versiones más recientes de macOS.
Para verificar la instalación de Git, abra un nuevo terminal de línea de comandos e
ingrese el siguiente comando:
$ git --version
git version 2.22.0
• Instalación en Windows.
• En un navegador de su sistema Windows, navegue hasta https://git-scm.com/
download/win y guarde el archivo ejecutable en su sistema.
• En Windows Explorer, navegue hasta el archivo descargado. Haga doble clic en el
archivo para iniciar el asistente de configuración. Si se le solicita, haga clic en Yes (Sí)
para permitir que el instalador realice cambios en su sistema.
• Haga clic en Next (Siguiente) para aceptar el acuerdo de licencia.
• Haga clic en Next (Siguiente) para aceptar la ubicación de instalación
predeterminada para Git. Si una ventana muestra una advertencia acerca de la
ubicación de instalación, haga clic en Yes (Sí) para continuar con la instalación de Git
en esa ubicación.
• Haga clic en Next (Siguiente) para aceptar la instalación del conjunto
predeterminado de componentes.
• Haga clic en Next (Siguiente) para aceptar la carpeta de menú de inicio
predeterminada.
• Seleccione Use Visual Studio Code as Git’s default editor (Usar
Visual Studio Code como editor predeterminado de Git) de la lista de editores para
usar VS Code como editor predeterminado. Haga clic en Next (Siguiente).
• En la petición Adjusting your PATH environment (Ajuste del entorno de
RUTA), haga clic en Next (Siguiente).
• Haga una elección adecuada para el transporte interno de HTTPS. Si no está seguro
de qué opción seleccionar, acepte la selección predeterminada. Haga clic en Next
(Siguiente).
• En la petición Configuring the line-ending conversions (Configuración
de las conversiones de finalización de línea), acepte la selección predeterminada y
haga clic en Next (Siguiente).
• Haga clic en Next (Siguiente) para aceptar los valores predeterminados del
emulador del terminal.
• En la petición Configuring extra options (Configuración de opciones
adicionales), haga clic en Next (Siguiente) para aceptar los valores predeterminados.
• Haga clic en Install (Instalar) para aceptar las características experimentales
predeterminadas e iniciar la instalación. Espere a que se complete la instalación y,
luego, continúe con el siguiente paso.
• Haga clic en Finish (Finalizar) para salir del asistente de configuración.
26 DO101-OCP4.2-es-1-20191127

2. Use VS Code para probar la instalación de Git. Configure su identidad de instalación de Git
con sus credenciales de GitHub.
2.1. Abra VS Code.
2.2. Haga clic en Terminal → New Terminal (Nuevo terminal) para abrir un terminal
integrado.
2.3. Ejecute git --version en el terminal integrado para probar la instalación de Git. El
comando imprime la versión de la instalación de Git en su sistema.
NOTA
VS Code depende de las opciones de configuración seleccionadas durante el
proceso de instalación de Git. Si el comando git --version falla en el terminal
integrado, intente reiniciar VS Code. A continuación, repita este paso para verificar
la instalación de Git.
2.4. En un navegador, diríjase a https://github.com. Si no tiene una cuenta de GitHub, cree
una. Inicie sesión en GitHub.
2.5. En el terminal integrado de VS Code, ejecute git config --global user.name
yourgituser, reemplazando yourgituser con su nombre de usuario de GitHub.
2.6. En el terminal integrado de VS Code, ejecute git config --global user.email
user@example.com, reemplazando user@example.com con la dirección de correo
electrónico asociada a su cuenta de GitHub.
Figura 1.22: Terminal integrado de VS Code
DO101-OCP4.2-es-1-20191127 27

NOTA
Git requiere su nombre de usuario y contraseña de GitHub para ciertas
transacciones con repositorios remotos.
En los sistemas Windows, Git administra estas credenciales de manera
predeterminada. Solo se le solicitan las credenciales la primera vez que se conecta a
un repositorio remoto.
De manera predeterminada, en los sistemas Linux y macOS, Git no administra sus
credenciales de repositorio remoto. Git solicitará sus credenciales cada vez que se
conecte a GitHub.
Para almacenar en caché sus credenciales en los sistemas Linux o macOS, ejecute
el siguiente comando desde un terminal del sistema:
$> git config --global credential.helper cache
3. Habilite la opción de administración de control de código fuente Always Show
Providers (Mostrar siempre los proveedores) en VS Code.
3.1. Acceda a la paleta de comandos (View (Ver) → Command Palette… (Paleta de
comandos...)) y escriba settings. Seleccione Preferences: Open Settings
(UI) (Preferencias: abrir configuración [IU]) de la lista de opciones.
3.2. Cuando aparezca la ventana Settings (Configuración), haga clic en User (Usuario)
→ Features (Funciones) → SCM.
3.3. VS Code muestra las opciones de gestión de control de código fuente (SCM) para VS
Code. Seleccione Always Show Providers (Mostrar siempre los proveedores).
28 DO101-OCP4.2-es-1-20191127

Figura 1.23: Opción para ver siempre la lista de proveedores de control
de código fuente en la vista de control de código fuente de VS Code
3.4. Cierre la pestaña Settings (Configuración).
4. Asegúrese de tener una carpeta de proyecto hello-nodejs en su espacio de trabajo de
VS Code. Si ya tiene una carpeta de proyecto hello-nodejs en su espacio de trabajo de
VS Code de un ejercicio anterior, omita este paso.
4.1. Descargue el siguiente archivo zip en su sistema:
https://github.com/RedHatTraining/DO101-apps/releases/download/v0.1/hello-
nodejs.zip.
Descomprima el archivo, que crea una carpeta hello-nodejs en su sistema. La
carpeta hello-nodejs contiene un único archivo: app.js. Observe la ubicación de la
carpeta hello-nodejs. Usará esta carpeta en un paso posterior.
4.2. Haga clic en File (Archivo) → Add Folder to Workspace... (Agregar carpeta al espacio
de trabajo...).
4.3. En la ventana del archivo, diríjase a la ubicación de la carpeta hello-nodejs
descomprimida. Seleccione la carpeta hello-nodejs y haga clic en Add (Agregar).
5. Inicialice el proyecto hello-nodejs como repositorio de Git.
5.1. Acceda a la paleta de comandos de VS Code (View (Ver) → Command Palette…
(Paleta de comandos...)).
5.2. Escriba initialize. VS Code proporciona una lista de posibles comandos que
coinciden con lo que se escribe. Seleccione Git: Initialize Repository (Git:
inicializar repositorio) de la lista de opciones de la paleta de comandos.
DO101-OCP4.2-es-1-20191127 29

Figura 1.24: Inicialización del repositorio de Git con la paleta de comandos
5.3. Seleccione hello-nodejs de la lista de carpetas del espacio de trabajo.
Figura 1.25: Solicitud de selección para inicializar un repositorio local de Git.
6. Cree una confirmación desde el archivo app.js.
6.1. Haga clic en View (Ver) → SCM para acceder a la vista de control de código
fuente en la barra de actividades.
6.2. Desplace el ratón sobre la entrada app.js en CHANGES (CAMBIOS). VS Code
muestra un mensaje que indica que el archivo app.js está sin rastrear. Haga clic en el
signo más para la entrada app.js a fin de agregar el archivo al repositorio.
Figura 1.26: Lista de archivos modificados
Esto prepara el archivo app.js para la siguiente confirmación. El archivo ahora
aparece en el encabezado STAGED CHANGES (CAMBIOS EN PREPARACIÓN).
6.3. Haga clic en el campo Message (press Ctrl+Enter to commit) Mensaje
[presione Ctrl+Intro para confirmar]). Escriba add initial app.js code en el
campo de mensaje. Haga clic en el ícono de marca de verificación para confirmar los
cambios.
30 DO101-OCP4.2-es-1-20191127

Figura 1.27: Cuadro de mensaje de confirmación de VS Code.
7. Cree un nuevo repositorio de GitHub para alojar los archivos de proyectos. Agregue el
repositorio de GitHub como repositorio remoto para su proyecto hello-nodejs local.
Publique su repositorio local en GitHub.
7.1. En un navegador, diríjase a https://github.com. Si no inició sesión en Github, inicie
sesión.
7.2. Haga clic en + en la parte superior derecha y, luego, seleccione New repository
(Nuevo repositorio) en la lista que aparece.
Figura 1.28: Creación de un nuevo repositorio de Git en GitHub
7.3. Escriba hello-nodejs en el campo Repository name (Nombre del repositorio).
De manera predeterminada, el repositorio es accesible públicamente. Si necesita un
repositorio privado, seleccione la casilla de verificación Private (Privado).
ADVERTENCIA
No seleccione Initialize the repository with a README (Inicializar el
repositorio con el archivo LÉAME). Tampoco agregue un archivo .gitignore ni
una licencia a su repositorio.
Cree un repositorio vacío para evitar un conflicto de combinación en un paso
posterior.
Haga clic en Create Repository (Crear repositorio) para crear el nuevo repositorio de
GitHub. Una página de resumen proporciona comandos de Git para una variedad de
escenarios de inicialización de proyectos:
DO101-OCP4.2-es-1-20191127 31

Figura 1.29: Página de resumen para un nuevo repositorio de GitHub
8. Agregue el nuevo repositorio de GitHub como repositorio remoto para el proyecto hello-
nodejs.
8.1. En VS Code, escriba Git: Add (Git: Agregar) en la paleta de comandos (View
(Ver) → Command Palette… (Paleta de comandos...)). Luego, seleccione Git: Add
Remote (Git: agregar repositorio remoto) de la lista de opciones.
Figura 1.30: Solicitud de URL remota para agregar un repositorio de Git remoto
8.2. Si tiene más de un repositorio local de Git en VS Code, seleccione hello-nodejs de
la lista de opciones.
Cuando se le solicite un nombre remoto, ingrese origin.
32 DO101-OCP4.2-es-1-20191127

NOTA
Un repositorio de Git puede interactuar con varios repositorios remotos. El nombre
remoto origin es una convención de Git para indicar el repositorio de origen para
un repositorio local de Git.
8.3. En la siguiente petición, ingrese la URL de HTTPS de su repositorio hello-nodejs
de GitHub. El formulario URL es: https://github.com/yourgituser/hello-
nodejs.
9. Publique sus confirmaciones del repositorio local en el repositorio de GitHub.
9.1. Ubique la entrada hello-nodejs en la sección SOURCE CONTROL PROVIDERS
(PROVEEDORES DE CONTROL DE CÓDIGO FUENTE) y, luego, haga clic en el ícono
"Publish Changes" (Publicar cambios).
Figura 1.31: Vista de control de código fuente con varios repositorios de Git en el espacio de trabajo.
La primera vez que VS Code se conecta a GitHub, solicita sus credenciales de GitHub.
Cuando se las solicite, proporcione su nombre de usuario y contraseña de GitHub.
9.2. Si esta es la primera vez que publica confirmaciones en VS Code, se muestra una
petición adicional:
Figura 1.32: Solicitud de VS Code de obtención periódica de nuevas confirmaciones
Haga clic en Yes (Sí) para configurar VS Code a fin de verificar periódicamente el
repositorio remoto en busca de nuevas confirmaciones.
10. En un navegador, diríjase a https://github.com/yourgituser/hello-nodejs,
reemplazando yourgituser con su nombre de usuario de GitHub. Verifique que el código
fuente esté presente en su repositorio de GitHub.
DO101-OCP4.2-es-1-20191127 33

Figura 1.33: Archivos de proyectos locales presentes en GitHub
11. Para eliminar su trabajo, haga clic en el ícono Kill Terminal (Eliminar terminal) para cerrar la
ventana del terminal integrado.
Esto concluye el ejercicio guiado.
34 DO101-OCP4.2-es-1-20191127

ADMINISTRACIÓN DEL CÓDIGO FUENTE
DE LA APLICACIÓN CON GIT
OBJETIVOS
Después de completar esta sección, podrá usar el control de versiones para administrar y
colaborar con el código fuente de la aplicación.
DESCRIPCIÓN GENERAL DE LA DERIVACIÓN DE GIT
El control de versiones de Git incluye un modelo de derivación para rastrear los cambios en el
código. Una rama es una referencia designada para una secuencia específica de confirmaciones.
Todos los repositorios de Git tienen una rama base denominada maestra. De manera
predeterminada, cuando crea una confirmación en su repositorio, la rama maestra se actualiza
con la nueva confirmación.
Figura 1.34: Confirmaciones de las ramas maestras del repositorio de Git.
Por convención, la rama maestra en un repositorio de Git contiene la versión más reciente y
estable del código fuente de la aplicación. Para implementar una nueva función o funcionalidad,
cree una nueva rama a partir de la rama maestra. Esta nueva rama, denominada rama de
funciones, contiene confirmaciones que corresponden a cambios de códigos para la nueva
función. La rama maestra no se ve afectada por las confirmaciones de la rama de funciones.
Figura 1.35: Confirmaciones de una rama de funciones del repositorio de Git.
DO101-OCP4.2-es-1-20191127 35

Cuando usa una derivación para el desarrollo de funciones, puede confirmar y compartir su código
con frecuencia sin que ello afecte la estabilidad del código en la rama maestra. Después de
asegurarse de que el código en la rama de funciones esté completo, probado y revisado, estará
listo para combinar la rama con otra rama, como la rama maestra. Esta fusión es el proceso de
combinación de los historiales de ejecuciones de dos ramas separadas en una única rama.
Figura 1.36: Combinación de una rama de funciones con la rama maestra.
Conflictos de combinación
Git tiene mecanismos sofisticados para combinar los cambios de códigos de una rama con otra
rama. Sin embargo, si hay cambios en el mismo archivo en ambas ramas, se puede producir un
conflicto de combinación.
Un conflicto de combinación indica que Git no puede determinar automáticamente cómo integrar
los cambios de ambas ramas. Cuando esto sucede, Git etiqueta cada archivo afectado como un
conflicto. VS Code muestra una entrada para cada archivo con un conflicto de combinación en la
vista de control de código fuente, debajo del encabezado Merge Changes (Fusionar cambios).
Cada archivo con una entrada de conflicto de combinación contiene una C a la derecha de la
entrada.
Figura 1.37: Conflicto de combinación en la vista de control de código fuente de VS Code
Git también inserta marcadores en cada archivo afectado para indicar las secciones que contienen
conflictos de contenido de ambas ramas. Si hace clic en la entrada del conflicto de combinación en
la vista de control de código fuente de VS Code, se mostrará una pestaña del editor y se resaltarán
las secciones del archivo que entran en conflicto.
36 DO101-OCP4.2-es-1-20191127

Figura 1.38: Conflictos resaltados en VS Code de un archivo de conflicto de combinación.
En la figura anterior, la sección resaltada en verde incluye contenido de la rama actual, en este
caso, la rama maestra. El texto resaltado en azul contiene cambios de la rama update-readme,
que se combina con la rama maestra.
Existen muchas opciones para resolver los conflictos de combinación que se producen como
resultado del proceso de combinación normal.
Para cada conflicto en un archivo conflictivo, reemplace todo el contenido entre los marcadores
de conflicto de combinación (<<<<<<<< y >>>>>>>> inclusive) con el contenido correcto de una
rama u otra, o una combinación adecuada del contenido de ambas ramas.
Por ejemplo, en la siguiente figura, se muestra que la sección de conflictos del ejemplo anterior se
reemplaza con contenido de las ramas maestra y update-readme.
Figura 1.39: Resolución de un conflicto de combinación en VS Code.
Después de reconciliar el contenido para cada conflicto en un archivo, guarde, prepare y confirme
los cambios en el archivo.
NOTA
La administración de conflictos de combinación está fuera del alcance de este
curso. Para obtener más información acerca de los conflictos de combinación,
consulte Conflictos de combinación básicos en https://git-scm.com/book/en/
v2/Git-Branching-Basic-Branching-and-Merging.
DO101-OCP4.2-es-1-20191127 37

ESTRATEGIAS DE COLABORACIÓN CON GIT
Git proporciona a los equipos de desarrollo la flexibilidad necesaria para implementar procesos de
colaboración de código y estrategias de derivación que se ajustan al tamaño y la dinámica de cada
equipo. Cuando un equipo acepta un flujo de trabajo de Git, los cambios del código se gestionan
de manera uniforme y aumenta la productividad del equipo.
Flujo de trabajo centralizado
Un flujo de trabajo centralizado de Git usa un repositorio central de Git como único origen
de registro para el código de la aplicación. El repositorio central normalmente se aloja en una
plataforma de alojamiento de repositorios, como GitHub. En este flujo de trabajo, el equipo de
desarrollo acepta que el repositorio central solo contendrá una única rama, la maestra. Los
desarrolladores envían los cambios del código directamente a la rama maestra y no envían las
confirmaciones de otras ramas al repositorio central.
Los desarrolladores clonan el repositorio central, creando una copia local de los repositorios
para cada desarrollador. Los desarrolladores realizan cambios en el código y ejecutan las
confirmaciones en la rama maestra del repositorio local. Los desarrolladores fusionan los últimos
cambios del repositorio remoto antes de enviar los nuevos cambios al repositorio remoto.
Debido a que el flujo de trabajo genera confirmaciones solo para una única rama, los miembros
del equipo son propensos a generar conflictos de combinación. Los conflictos de combinación se
reducen cuando los equipos identifican claramente los cambios de códigos separados para cada
miembro del equipo que se pueden implementar en archivos distintos.
Además de los conflictos de combinación, este flujo de trabajo permite asignar cambios
de códigos parciales o incompletos a la rama maestra. Cuando se confirman los cambios
incompletos del código, la estabilidad del código en la rama maestra se ve comprometida.
Los equipos que utilizan un flujo de trabajo centralizado deben adoptar procesos adicionales y
estrategias de comunicación para mitigar los riesgos de la estabilidad del código del proyecto en
la rama maestra.
Una forma en que los equipos mitigan los problemas de estabilidad de código con un flujo de
trabajo centralizado es a través de la implementación de etiquetas de Git en el repositorio
de códigos. Una etiqueta es una referencia legible para el ser humano de una confirmación
específica en un repositorio de Git, independientemente de cualquier rama. Los equipos pueden
implementar una nomenclatura de etiquetas para identificar las confirmaciones correspondientes
a las versiones estables del código fuente del proyecto.
NOTA
Las etiquetas de Git están fuera del alcance de este curso. Consulte Etiquetado en
la documentación de Git en https://git-scm.com/book/en/v2/Git-Basics-Tagging.
El flujo de trabajo centralizado de Git funciona bien para los equipos pequeños que colaboran en
un proyecto pequeño con cambios de códigos poco frecuentes, pero se complica la gestión con
equipos más grandes y proyectos de códigos de gran tamaño.
Flujo de trabajo de rama de funciones
Un flujo de trabajo de rama de funciones implementa mecanismos de seguridad para proteger la
estabilidad del código en la rama maestra. El objetivo de este flujo de trabajo es siempre tener un
código desplegado y estable para cada confirmación en la rama maestra; aun así, permite a los
miembros del equipo desarrollar y aportar nuevas funciones al proyecto.
38 DO101-OCP4.2-es-1-20191127

En un flujo de trabajo de rama de funciones, cada nueva función se implementa en una rama
dedicada. Varios colaboradores cooperan con la función al confirmar el código para la rama de
funciones. Una vez completada, probada y revisada una función en la rama de funciones, la función
se combina en la rama maestra.
El flujo de trabajo de rama de funciones es una extensión del flujo de trabajo centralizado. Un
repositorio central es la fuente de registro para todos los archivos de proyectos, incluidas las ramas
de funciones.
Cuando un desarrollador está listo para combinar una rama de funciones con la rama maestra,
el desarrollador envía la rama de funciones local al repositorio remoto. A continuación, el
desarrollador envía una solicitud al equipo, por ejemplo, una solicitud de extracción o una solicitud
de fusión, para que los cambios en el código se realicen en una rama de funciones revisada por un
miembro del equipo. Después de que un miembro del equipo apruebe la solicitud, la plataforma de
alojamiento de repositorios combinará la rama de funciones con la rama maestra.
NOTA
Una solicitud de extracción es una función de varias plataformas de alojamiento
de repositorios, entre las que se incluyen GitHub y BitBucket.
Una solicitud de extracción permite enviar el código para su inclusión en una
base de código de proyecto. A menudo, las solicitudes de extracción brindan
a los miembros del equipo una forma de proporcionar comentarios, preguntas
y sugerencias acerca de los cambios en el código enviado. Las solicitudes de
extracción también proporcionan un mecanismo para aprobar la combinación de los
cambios del código en otra rama, como la maestra.
En otras plataformas, como GitLab y SourceForge, esta función de revisión de
códigos se denomina solicitud de fusión.
Por ejemplo, en la siguiente figura, se muestra la interfaz de usuario de GitHub después de
presionar la rama feature1. GitHub muestra una notificación de que ha enviado recientemente
la rama feature1. Para enviar una solicitud de extracción para la rama feature1, haga clic en
Compare & pull request (Solicitud de extracción y comparación) en la notificación.
Figura 1.40: Interfaz de usuario de GitHub después del envío de una rama de funciones.
GitHub muestra un formulario que debe completar para enviar la solicitud de extracción.
De manera predeterminada, solicita que la rama feature1 se combine (o extraiga) en la rama
maestra. Si desea combinar la rama de funciones con una rama diferente, seleccione la rama
base correcta de la lista de opciones. GitHub muestra un mensaje para indicar si la operación
de combinación producirá conflictos. En la siguiente figura, GitHub indica que las dos ramas se
combinarán sin conflictos y se podrán combinar automáticamente.
DO101-OCP4.2-es-1-20191127 39

El formulario de solicitud de extracción de GitHub permite proporcionar un título y una
descripción para la solicitud de extracción. El formulario también permite asignar la solicitud de
extracción a un usuario de GitHub y especificar un conjunto de usuarios de GitHub para revisar los
cambios de códigos en la solicitud de extracción.
Después de completar el formulario, haga clic en Create pull request (Crear solicitud de
extracción) para crear la solicitud de extracción.
Figura 1.41: Formulario de GitHub para enviar una solicitud de extracción.
Una vez que un revisor otorga la aprobación, puede combinar la solicitud de extracción.
Haga clic en Pull requests (Solicitudes de extracción) para que el repositorio de GitHub muestre
una lista de solicitudes de extracción. Seleccione su solicitud de extracción de la lista. GitHub
muestra información acerca de la solicitud de extracción, incluidos comentarios, preguntas o
sugerencias por parte de otros revisores. Cuando esté listo para combinar los cambios en la rama
maestra, haga clic en Merge pull request (Combinar solicitud de extracción).
Figura 1.42: Solicitud de extracción de GitHub.
40 DO101-OCP4.2-es-1-20191127

GitHub muestra un mensaje para la operación de combinación. Haga clic en Confirm merge
(Confirmar combinación) para combinar la rama feature1 con la rama maestra. A continuación,
GitHub muestra el botón Delete branch (Eliminar rama).
Por último, en el flujo de trabajo de rama de funciones, elimine la rama de funciones después de
que se combine con la rama maestra. Haga clic en Delete branch (Eliminar rama) para eliminar la
rama.
Flujo de trabajo del repositorio bifurcado
El flujo de trabajo del repositorio bifurcado se usa a menudo con grandes proyectos de código
abierto. Con una gran cantidad de colaboradores, la gestión de ramas de funciones en un
repositorio central es difícil. Además, es posible que el propietario del proyecto no desee permitir
que los colaboradores creen ramas en el repositorio de códigos. En esta situación, la creación de
ramas en el repositorio central se limita a un pequeño número de miembros del equipo. El flujo
de trabajo de repositorio bifurcado permite que un gran número de desarrolladores contribuya al
proyecto manteniendo la estabilidad del código del proyecto.
En un flujo de trabajo de repositorio bifurcado, cree una bifurcación del repositorio central, que
se convertirá en su copia personal del repositorio en la misma plataforma de alojamiento.
Después de crear la bifurcación del repositorio, clónela. A continuación, use el flujo de trabajo
de rama de funciones para implementar los cambios en el código y enviar una nueva rama de
funciones a la bifurcación del repositorio oficial.
Luego, abra una solicitud de extracción para la nueva rama de funciones en su bifurcación.
Después de que un representante del repositorio oficial apruebe la solicitud de extracción, la rama
de funciones de la bifurcación se combina con el repositorio original.
Por ejemplo, considere el flujo de trabajo del repositorio de origen de GitHub de OpenShift.
Figura 1.43: Repositorio de origen de GitHub de OpenShift
Hay más solicitudes de extracción que ramas en el repositorio de origen de GitHub de OpenShift.
Muchas de las solicitudes de extracción (si no todas) contienen un código de una de las
bifurcaciones del repositorio en lugar de la rama del repositorio.
DERIVACIÓN DE GIT EN VS CODE
En VS Code, use la vista de control de código fuente (View (Ver) → SCM) para acceder a las
funciones de rama en Git. La sección PROVEEDORES DE CONTROL DE CÓDIGO FUENTE
contiene una entrada para cada repositorio de Git en su espacio de trabajo de VS Code. Cada
entrada muestra la rama actual para el repositorio.
DO101-OCP4.2-es-1-20191127 41

Figura 1.44: La vista de control de código fuente muestra la
rama actual para cada repositorio del espacio de trabajo de Git.
Para cambiar a una rama diferente en un repositorio, haga clic en el nombre de la rama actual para
la entrada de repositorio en el encabezado SOURCE CONTROL PROVIDERS (PROVEEDORES DE
CONTROL DE CÓDIGO FUENTE). VS Code muestra dos opciones para crear una nueva rama y
una lista de ramas y etiquetas existentes en el repositorio:
Figura 1.45: Comprobación de una rama en la vista de control de código fuente.
Cuando selecciona cualquiera de las dos opciones para crear una nueva rama, VS Code solicita un
nombre para asignar a la nueva rama. Si seleccionó la opción Create new branch... (Crear
nueva rama...), VS Code crea una nueva rama a partir de la rama actual del repositorio.
Si seleccionó la opción Create a new branch from... (Crear nueva rama de...), VS Code
además proporciona una lista de ramas y etiquetas de repositorios existentes. Después de
seleccionar un elemento, VS Code crea una nueva rama que comienza a partir de la etiqueta o la
rama seleccionada.
42 DO101-OCP4.2-es-1-20191127

NOTA
A menudo, los proyectos de software adoptan convenciones o estándares de
nombres de ramas. Los estándares de nombres de ramas permiten resumir los
cambios de códigos contenidos en una rama.
Los siguientes son ejemplos de plantillas de nomenclatura de ramas para un
estándar de nombre de rama:
• feature/feature-id/description
• hotfix/issue-number/description
• release/release-string
Un estándar de nombre de rama también define el conjunto de caracteres
permitidos. Los nombres de ramas generalmente se limitan a caracteres
alfanuméricos y separadores de campos (como los caracteres /, _ o -).
Después de que VS Code crea la nueva rama local, la vista de control de código fuente actualiza
la entrada de repositorio con el nombre de la nueva rama. Cuando hace clic en el ícono Publish
Changes (Publicar cambios), VS Code publica la nueva rama local en el repositorio remoto.
Cualquier código nuevo que confirma se agrega a la nueva rama local. Cuando esté listo para
enviar las confirmaciones locales al repositorio remoto, haga clic en el ícono Synchronize
Changes (Sincronizar cambios) en la vista de control de código fuente. El ícono Synchronize
Changes (Sincronizar cambios) muestra:
• La cantidad de confirmaciones en el repositorio local para cargar.
• La cantidad de confirmaciones en el repositorio remoto para descargar.
Para descargar las confirmaciones desde un repositorio remoto, VS Code primero obtiene las
confirmaciones remotas y las combina en su repositorio local. A continuación, VS Code envía las
confirmaciones locales al repositorio remoto.
Figura 1.46: Envío de una confirmación local al repositorio remoto
DO101-OCP4.2-es-1-20191127 43

REFERENCIAS
Para obtener más información sobre las ramas de Git, consulte la documentación de
Git en
https://git-scm.com/book/en/v2/Git-Branching-Branches-in-a-Nutshell
Para obtener más información sobre las combinaciones, consulte la documentación
de Git en
https://git-scm.com/book/en/v2/Git-Branching-Basic-Branching-and-Merging
Para obtener más información sobre el uso de Git y el control de versiones en VS
Code, consulte la documentación de VS Code en
https://code.visualstudio.com/docs/editor/versioncontrol
44 DO101-OCP4.2-es-1-20191127

Introducción a las aplicaciones de OpenShift

Introducción a las aplicaciones de OpenShift

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (20)

Similar a Introducción a las aplicaciones de OpenShift

Similar a Introducción a las aplicaciones de OpenShift (20)

Más de Andy Juan Sarango Veliz

Más de Andy Juan Sarango Veliz (20)

Último

Último (20)

Introducción a las aplicaciones de OpenShift