Despliegue continuo con Jenkins y .NET

Este es el primer post de dos sobre Jenkins y Couchbase. Este primer post es una introducción general al Despliegue Continuo: vas a aprender a usar Jenkins para desplegar una aplicación .NET automáticamente. La segunda entrada del blog se centrará más en cómo utilizar Jenkins para configurar los datos de prueba en Couchbase antes de ejecutar el código de prueba.

Como desarrollador .NET es probable que utilices Visual Studio. Al pulsar F5 en Visual Studio se compila el código fuente y se inicia el depurador. Si eres como yo, pulsarás F5 muchas veces durante el desarrollo y la búsqueda de errores.

Pero, ¿qué ocurre cuando el código está listo? Se despliega.

Cuando necesito publicar una aplicación, suelo elegir la opción más perezosa: copiar manualmente el ejecutable en el destino, instalar manualmente e iniciar manualmente la aplicación.

Es "divertido" las primeras veces, pero al final se vuelve realmente difícil; en particular, hacer un seguimiento de los cambios y las actualizaciones/despliegues manuales. Para ser sinceros, este enfoque manual no funciona muy bien: lleva un tiempo innecesario y es propenso a errores humanos en el proceso de despliegue.

Una opción más madura sería disponer de una infraestructura automatizada para gestionar el despliegue. Este tipo de infraestructura suele denominarse integración continua/despliegue continuo.

El uso de la Integración Continua/Despliegue Continuo, permite un flujo de trabajo como este:

• Codifique, compile y pruebe localmente en su equipo de desarrollo (como de costumbre).
• Compruebe el código fuente en una rama de desarrollo en su sistema de gestión de control de código fuente favorito.
• Revisión opcional del código por los miembros del equipo.
• Fusione sus cambios en la rama principal (release).
• El servidor CI detectará los cambios en la rama principal y descargará, compilará y desplegará/instalará su aplicación en el servidor de publicación.

No hay pasos manuales: todo está programado y es automático.

Despliegue continuo

Puedes elegir entre varias herramientas de Integración/Despliegue Continuo (CI), cada una con sus propias advertencias. En mi caso, necesito un servidor de integración continua que entienda los componentes de mi aplicación.

Echemos un vistazo a la arquitectura y los componentes de mi aplicación:

• Plataforma.NET 4.5.2
• IDE: Visual Studio 2015 (archivos MSBuild)
• Tipo de aplicación: Servicio Windows
• NuGet: Gestor de paquetes utilizado para todas las referencias.
• Control de las fuentes: Git (github.com)

El servidor CI debe ser capaz de entender todos los componentes mencionados anteriormente y (como soy perezoso) debe ser realmente fácil de mantener y configurar.

Investigué un poco y, por las experiencias de otras personas y las entradas del blog, descubrí que lo mejor es utilizar Jenkins desplegar un servicio Windows.

Jenkins

Jenkins es un servidor de construcción con una arquitectura de plugins que permite a la comunidad ampliar lo que Jenkins puede "entender". Esta arquitectura facilita la ampliación de Jenkins para que admita archivos MSBuild, control de versiones Git, etc.

Conoce a Jenkins

Puesta en marcha

Jenkins está instalado en un servidor de compilación. En mi configuración, el servidor de compilación es el mismo que el servidor de publicación, pero puede configurarse de forma diferente.

Descargar e instalar Jenkins para su plataforma aquí: https://jenkins-ci.org/

Tras la instalación, Jenkins está disponible en su puerto por defecto: http://localhost:8080/

Configurar Jenkins

Jenkins tiene plugins para entender repositorios Git, archivos MSBuild y varias otras tecnologías. En la configuración actual solo necesitamos ampliar Jenkins con esos dos plugins.

Instale el plugin Git para Jenkins:

1. Open Jenkins, http://localhost:8080/
2. Vaya a "Gestionar Jenkins".
3. Vaya a "Administrar plugins".Enlace directo: http://localhost:8080/pluginManager
4. Utiliza la casilla "filtro" para buscar "Git plugin" e instalar el plugin.

Instale el plugin MSBuild para Jenkins:

1. Open Jenkins, http://localhost:8080/
2. Vaya a "Gestionar Jenkins".
3. Vaya a "Administrar plugins".Enlace directo: http://localhost:8080/pluginManager
4. Utiliza la casilla "filtro" para buscar "MSBUILD plugin" e instalar el plugin.Jenkins ahora entiende los archivos MSBuild y el control de código fuente Git, pero todavía tenemos que configurar el plugin MSBuild con una ruta al archivo msbuild.exe que nos gustaría utilizar.

Configuración de MSBuild

Cuando se instaló el plugin MSBuild, éste añadió sus propias opciones de configuración a la página de configuración global de Jenkins.

1. Vaya a http://localhost:8080/
2. Haga clic en "Gestionar Jenkins".
3. Haga clic en "Configurar sistema".
4. Desplácese por la lista hasta encontrar "MSBuild".
5. Haga clic en el botón "Instalaciones MSBuild...".
6. Haga clic en "Añadir MSBuild".
7. Dale a la nueva configuración de MSBuild un nombre como "MSBuild-default".
8. En el campo de ruta, introduzca la ruta completa a msbuild.exeEn mi servidor la ruta es: C:Archivos de programa (x86)MSBuild14.0Binmsbuild.exeLea más abajo para obtener más información sobre MSBuild y cómo instalarlo.
9. Haz clic en Guardar.

Instalación de MSBuild

MSBuild se instala con Visual Studio, es el sistema de compilación que utiliza Visual Studio cuando seleccionas "compilar" o pulsas "F5".

No siempre es posible instalar Visual Studio en la máquina de compilación. Esto puede deberse a problemas de licencia, seguridad, etc.

Para acomodar esto Microsoft ha lanzado un paquete separado llamado: "Microsoft Build Tools 2015" que contiene todo lo necesario para utilizar MSBuild.

Descarga directa: https://www.microsoft.com/en-us/download/details.aspx?id=48159

Después de la instalación con éxito tiene MSBuild disponible en el servidor de compilación y con eso se obtiene el valor de la ruta para el paso 8, arriba.

Con este paso hecho Jenkins está listo para construir y desplegar con MSBuild y Git.

Crear un nuevo proyecto de compilación Jenkins

Ahora es el momento de apuntar a Jenkins al código fuente y empezar a construir.

1. Open Jenkins, http://localhost:8080/
2. Enlace directo http://localhost:8080/view/All/newJob
3. Dale al proyecto un nombre "Windows Service Deployment" o algo que puedas recordar.
4. Selecciona "Proyecto Freestyle".
5. Seleccione "Ok".
6. A continuación, amplíe la región "Gestión del código fuente" seleccionando "Git".
7. Completa la configuración de Git rellenando los espacios en blanco con una URL a tu repositorio y opcionalmente las credenciales (si son necesarias).Jenkins también puede trabajar con ramas. En esta configuración dejaré la rama por defecto (Master) pero puedes seleccionar la que se ajuste a tus necesidades.Si aún no tienes un repositorio Git listo para probar, puedes usar el repositorio precocinado aquí:https://github.com/martinesmann/jenkins-ci-templateEl código fuente contiene algunos archivos más que la solución "Hello Windows Service" habitual. Voy a explicar las partes pertinentes más adelante, ya que se utilizan. Por ahora vamos a tratar esto como una solución "Hola Mundo".
8. Si aún no lo ha hecho, haga clic en "Guardar" para conservar los cambios y volver a la página principal del "Proyecto".

Probar la configuración de Git

Ahora podemos comprobar si la pestaña Git Source Management se ha configurado correctamente y que podemos clonar el código fuente.

Todavía no estamos construyendo nada, sólo clonando la fuente. La construcción vendrá en un momento. Primero, asegurémonos de que Jenkins puede clonar el código fuente desde el repositorio.

1. Vaya a la página "Proyecto
2. Haga clic en "Construir ahora" para iniciar una "Construcción".
3. En la región "Historial de construcciones" deberías ver ahora una construcción en curso con el nombre "#1".
4. Si todo se completa como se esperaba "ÉXITO" entonces el creador de burbujas permanece azul, si no se pone rojo.
5. Para ver los detalles de la versión, haz clic en el número de versión "#1".
6. A continuación, haga clic en "Salida de la consola". Usted debe ver algo similar a lo que tengo aquí:
   
   Started by user anonymous Building in workspace C:Program Files (x86)JenkinsjobsWindows Service deploymentworkspace Cloning the remote Git repository Cloning repository https://github.com/martinesmann/jenkins-ci-template > git.exe init C:Program Files (x86)JenkinsjobsWindows Service deploymentworkspace # timeout=10 Fetching upstream changes from https://github.com/martinesmann/jenkins-ci-template > git.exe --version # timeout=10 > git.exe -c core.askpass=true fetch --tags --progress https://github.com/martinesmann/jenkins-ci-template +refs/heads/*:refs/remotes/origin/* > git.exe config remote.origin.url https://github.com/martinesmann/jenkins-ci-template # timeout=10 > git.exe config --add remote.origin.fetch +refs/heads/*:refs/remotes/origin/* # timeout=10 > git.exe config remote.origin.url https://github.com/martinesmann/jenkins-ci-template # timeout=10 Fetching upstream changes from https://github.com/martinesmann/jenkins-ci-template > git.exe -c core.askpass=true fetch --tags --progress https://github.com/martinesmann/jenkins-ci-template +refs/heads/*:refs/remotes/origin/* > git.exe rev-parse "refs/remotes/origin/master^{commit}" # timeout=10 > git.exe rev-parse "refs/remotes/origin/origin/master^{commit}" # timeout=10 Checking out Revision db11bee4586694774f21e9f38b57af8535c88e1e (refs/remotes/origin/master) > git.exe config core.sparsecheckout # timeout=10 > git.exe checkout -f db11bee4586694774f21e9f38b57af8535c88e1e First time build. Skipping changelog. Finished: SUCCESS

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

   Comenzó por usuario anónimo Edificio en espacio de trabajo C:Programa Archivos (x86)JenkinsjobsWindows Servicio despliegueespacio de trabajo Clonación el remoto Git repositorio Clonación repositorio https://github.com/martinesmann/jenkins-ci-template > git.exe init C:Programa Archivos (x86)JenkinsjobsWindows Servicio despliegueespacio de trabajo # tiempo de espera=10 Buscar en aguas arriba cambia de https://github.com/martinesmann/jenkins-ci-template > git.exe --versión # tiempo de espera=10 > git.exe -c núcleo.askpass=verdadero buscar --etiquetas --progreso https://github.com/martinesmann/jenkins-ci-template +refs/heads/*:refs/remotes/origin/* > git.exe config remoto.origen.url https://github.com/martinesmann/jenkins-ci-template # timeout=10 > git.exe config --añada remoto.origen.buscar +refs/cabezas/*:refs/mandos a distancia/origen/* # tiempo de espera=10 > git.exe config remoto.origen.url https://github.com/martinesmann/jenkins-ci-template # timeout=10 Buscar en aguas arriba cambia de https://github.com/martinesmann/jenkins-ci-template > git.exe -c núcleo.askpass=verdadero buscar --etiquetas --progreso https://github.com/martinesmann/jenkins-ci-template +refs/heads/*:refs/remotes/origin/* > git.exe rev-analizar "refs/remotes/origin/master^{commit}" # tiempo de espera=10 > git.exe rev-analizar "refs/remotes/origin/origin/master^{commit}" # tiempo de espera=10 Comprobación de fuera Revisión db11bee4586694774f21e9f38b57af8535c88e1e (refs/mandos a distancia/origen/maestro) > git.exe config núcleo.sparsecheckout # tiempo de espera=10 > git.exe checkout -f db11bee4586694774f21e9f38b57af8535c88e1e En primer lugar tiempo construya. Saltar registro de cambios. Terminado: ÉXITO

   
   *Lo que es importante destacar aquí es la ruta al "espacio de trabajo", ya que es aquí donde se descarga el código fuente y desde donde se construye. Este conocimiento puede ser muy útil a la hora de depurar la configuración de CI.*

Construir la fuente

El siguiente paso es compilar y construir el código fuente.

1. Ir a la página "proyecto
2. Seleccione "Configurar".
3. Busque la opción "Añadir paso de compilación"
4. Seleccione la opción "Build a Visual Studio project or solution using MSBuild".Necesitamos configurar algunos valores aquí:
   1. En primer lugar, seleccione la versión de MSBuild (la configuramos en un paso anterior).
   2. A continuación, indique la ruta del archivo *.sln o *.proj de su proyecto.Para el repositorio precocinado la ruta es: srcMyWindowsServiceMyWindowsServiceDeploy-Windows-Service-Via-MSBuild.projAtención: No estamos apuntando al archivo de la solución, sino a un archivo MSBuild personalizado que se encuentra en el proyecto. Este archivo MSBuild está manejando todos los pasos involucrados con la compilación y despliegue del servicio de Windows.Si está utilizando el repositorio precocinado, su configuración debería tener este aspecto:
   3. Haz clic en Guardar

Restauración de paquetes NuGet

Si tuviéramos que construir el proyecto en este momento fallaría debido a la falta de paquetes NuGet. Por lo tanto tenemos que restaurar los paquetes NuGet antes de intentar construir la fuente.

nuget.exe hace esta tarea muy fácil, simplemente tenemos que disparar este comando en el archivo de la solución:

nuget restore "ruta al archivo *.sln

No sorprende que Jenkins pueda manejar múltiples pasos de compilación, así que agreguemos un paso de compilación para habilitar la restauración de NuGet.

1. Vaya a la página "proyecto".
2. Seleccione "Configurar".
3. Busque la opción "Añadir paso de compilación".
4. Haga clic en "Añadir paso de compilación".
5. Seleccione "Ejecutar comando por lotes de Windows".
6. Reorganice el orden de construcción arrastrando el nuevo paso de construcción a la parte superior.
7. En el campo Comando inserte:nuget restore srcMiServicioWindows
8. Haz clic en "Guardar".

Ya estamos listos para construir el proyecto.

¡La prueba final! ¡Primera hora!

1. Ir a la página del proyecto
2. Haga clic en el enlace "Construir ahora
3. Espere a que finalice la compilación
4. Abra el "Explorador de Windows" y vaya a C:
5. Confirme que el archivo "MyWindowsService.log" existe.
6. Abra el archivo y lea el contenido del registro. Este archivo ha sido creado por nuestro recién instalado servicio de Windows.
7. Compruebe que el Servicio está instalado y en funcionamiento:
   1. En Windows, abra la ventana de gestión "Servicios
   2. Desplácese hacia abajo hasta encontrar el servicio "Mi servicio Windows (...)"

¡Felicidades! Ha configurado con éxito Jenkins para descargar, compilar y desplegar un servicio .NET Windows. ¡Automatización ROCKS!

El código fuente:

Hasta ahora no hemos prestado mucha atención al código fuente, pero tomémonos un momento para recorrer el contenido y la estructura del repositorio.

Si navega a la raíz del repositorio en:

https://github.com/martinesmann/jenkins-ci-template

encontrará todos los archivos habituales como README, etc., pero también un archivo llamado nuget.exe.

nuget.exe es el ejecutable utilizado para restaurar las dependencias de paquetes NuGet de la solución. Se podría discutir si es o no una buena práctica tener archivos binarios en el control de código fuente, pero en este caso es una dependencia necesaria para el sistema de construcción y por lo tanto lo he incluido.

He colocado nuget.exe en la raíz, para mantenerlo separado del código fuente real y que sea fácil de encontrar al configurar la compilación en Jenkins.

Si navegamos más profundamente en el repositorio para src/MyWindowsService/MyWindowsService/ encontramos cuatro archivos que hacen todo el trabajo duro de compilar e instalar el servicio de Windows.

El archivo de entrada principal es Despliegue-Windows-Service-Via-MSBuild.proj es un archivo MSBuild construido para, no sólo, compilar el código fuente; sino también: detener, desinstalar e iniciar la aplicación Windows Service. Esto se logra llamando a los tres archivos por lotes según sea necesario: safeServiceDelete.bat, safeServiceStart.bat y safeServiceStop.bat.

Está fuera del alcance de esta entrada del blog explicar en detalle lo que hace cada uno de los cuatro archivos, pero si echa un vistazo a los archivos individualmente estoy seguro de que obtendrá una muy buena comprensión de su funcionamiento interno y la forma en que colaboran.

El código fuente del servicio de Windows se puede ver y editar en Visual Studio para adaptarlo a tus necesidades específicas. El código fuente de ejemplo proporcionado en el repositorio es muy sencillo y sólo escribe unas pocas entradas en un archivo de texto (archivo de registro) y también "upserts" un documento a Couchbase Server:

Servicio1.cs

Si eres nuevo en Couchbase te sugiero que eches un vistazo a nuestro tutorial .NET aquí:

try-cb-dotnet.

Cree su propio

La forma más fácil de utilizar Jenkins y .NET para compilar y desplegar Su propio servicio automatizado de Windows sería probablemente clonar este repositorio y cambiar el código del servicio en Visual Studio para adaptarlo a sus necesidades.

Gracias por leerme.