Artículos etiquetados con:maven
Cómo crear desplegar un artefacto con Maven

Uno de los propósitos de QA es generar modelos que aporten consistencia y organización a la hora de trabajar en proyectos de automatización.

Si además queremos que este modelo se sustente en la unificación de las bases de proyectos, la opción es Maven. Dicho esto, la primera pregunta que puede surgir es, ¿y por qué no con Gradle?

Lo cierto es que, a pesar de que su uso parece estar generalizándose, la gran mayoría de los proyectos basados en automatización siguen usando Maven. Además cuenta con una documentación mucho más extensa. Siendo sinceros, aunque empieces a utilizar Gradle para la automatización, finalmente acabarás recurriendo a Maven.

En este post veremos cómo crear, configurar y distribuir artefactos de nuestros proyectos para mejorar los procesos de desarrollos futuros.

 

QUÉ ES MAVEN

En primer lugar debemos entender qué es Maven y el beneficio que nos aporta. Nuestra idea es usarlo para desplegar un artefacto.

Maven es una herramienta que nos simplificará los procesos de desarrollo de un proyecto. Una de las principales ventajas es tenerlo todo centralizado en un fichero llamado POM (Project Object Model), el cual nos aportará toda la información y configuración del proyecto.

Este fichero está dividido en diversas secciones, pero para nuestro propósito nos centraremos principalmente en dos:

  • Configuración de la construcción
  • Configuración del entorno

 

CONFIGURACIÓN DE LA CONSTRUCCIÓN

Contiene la configuración de los plugins e informes que usaremos durante el ciclo de vida de la construcción. Éste se divide en varias etapas con las que podemos alterar el comportamiento del proyecto:

  • Validación
  • Compilación
  • Test
  • Empaquetado
  • Test de integración
  • Verificación
  • Instalación
  • Despliegue

Estas fases tienen una ejecución lineal. Esto quiere decir que, siguiendo la lista anterior, si quisiéramos usar la fase de verificación, previamente Maven pasaría por todas las fases anteriores.

 

CONFIGURACIÓN DEL ENTORNO

Será la encargada de definir los entornos externos a nuestro proyecto que necesitaremos, y los perfiles o requisitos para diferentes configuraciones dentro del mismo entorno. Algunas de las posibles configuraciones son las siguientes:

  • Distribuciones
  • Incidencias
  • Integración continua
  • Cadena de suministros
  • Prerrequisitos
  • Repositorios
  • Perfiles

 

 

QUÉ ES UN ARTEFACTO

A grandes rasgos, un artefacto es un conjunto de funciones, acciones y servicios que almacenamos conjuntamente en un único lugar para que cualquier persona pueda disponer de ellos y poder usarlos.

Así conseguimos tener un proyecto modularizado que nos permita beneficiarnos de todo lo creado. Además, si requerimos de una actualización o necesitamos añadir nuevos artefactos, el impacto de los cambios sobre nuestro proyecto será muy bajo.

 

 

CONFIGURAR UN ARTEFACTO

Para poder llevar a cabo el despliegue de un artefacto, debemos configurar nuestro POM del proyecto siguiendo el siguiente modelo.

A continuación, planteamos un ejemplo de los pasos a seguir para configurar un artefacto que posteriormente pueda ser usado.

 

CONFIGURACIÓN DE LA CONSTRUCCIÓN

Usaremos plugins que se centrarán en cuatro fases del ciclo de vida del proyecto: compilación, empaquetado, verificación y despliegue. Aunque pasaremos por todas, éstas son las fases que nos afectarán principalmente a la hora de generar el artefacto.

maven-compiler-plugins

El compilador será el primero. Simplemente estableceremos para qué versión de Java queremos compilar el código fuente del proyecto. Esto no un requisito necesario pero sí importante para poder evitar incompatibilidades dentro del proyecto.

<plugin>
	<groupId>org.apache.maven.plugins</groupId>
	<artifactId>maven-compiler-plugin</artifactId>
	<version>3.7.0</version>
	<configuration>
		<source>1.8</source>
		<target>1.8</target>
	</configuration>
</plugin>

 

maven-jar-plugin

El empaquetador tendrá el papel de establecer el formato del código compilado. En nuestro caso emplearemos el tipo JAR, pero estos pueden ser diversos según la necesidad.

<plugin>
	<groupId>org.apache.maven.plugins</groupId>
	<artifactId>maven-jar-plugin</artifactId>
	<version>3.0.2</version>
	<executions>
		<execution>
			<id>jar</id>
			<goals>
				<goal>test-jar</goal>
			</goals>
		</execution>
	</executions>
</plugin>

 

maven-source-plugin

Dentro del grupo de empaquetadores, tenemos algunos plugins adicionales que usaremos sobre todo para añadir más información al artefacto final. En nuestro ejemplo hemos introducido el máximo de información al artefacto. Por ello, añadimos el código sin compilar para que sea accesible bajo el proyecto que lo usara y el javadoc que serán todas las descripciones de los componentes del artefacto.

<plugin>
	<groupId>org.apache.maven.plugins</groupId>
	<artifactId>maven-source-plugin</artifactId>
	<version>2.0.4</version>
	<executions>
		<execution>
			<id>attach-sources</id>
			<goals>
				<goal>jar</goal>
			</goals>
		</execution>
	</executions>
</plugin>

 

maven-javadoc-plugin

Será el encargado de establecer la configuración de empaquetado de toda la documentación en una distribución de tipo JAR.

<plugin>
	<groupId>org.apache.maven.plugins</groupId>
	<artifactId>maven-javadoc-plugin</artifactId>
	<version>3.0.0</version>
	<executions>
		<execution>
			<id>attach-javadocs</id>
			<goals>
				<goal>jar</goal>
			</goals>
		</execution>
	</executions>
</plugin>

 

maven-jarsigner-plugin

Para la parte de seguridad añadimos, como buenas prácticas, un firmado. Así nos aseguramos de que no está modificado por un tercero.

Usando este plugin verificamos que el firmado sea correcto. Simplemente se necesita configurar un contenedor de firmas y la firma que deseemos usar sobre el artefacto.

<plugin>
	<groupId>org.apache.maven.plugins</groupId>
	<artifactId>maven-jarsigner-plugin</artifactId>
	<version>1.4</version>
	<executions>
		<execution>
			<id>sign</id>
			<goals>
				<goal>sign</goal>
			</goals>
		</execution>
		<execution>
			<id>verify</id>
			<goals>
				<goal>verify</goal>
			</goals>
		</execution>
	</executions>
	<configuration>
		<keystore>src/main/resources/keystore.jks</keystore>
		<alias>myalias</alias>
		<storepass>password</storepass>
		<keypass>password</keypass>
	</configuration>
</plugin>

 

CONFIGURACIÓN DEL ENTORNO

Para finalizar sólo nos queda configurar el entorno. Para ello, emplearemos únicamente el gestor de distribuciones que será el que subirá a un repositorio privado nuestro artefacto.

Eso sí, debemos tener en cuenta que tendremos dos tipos de versiones de artefacto:

  • En desarrollo
  • De distribución

Como Maven autogestiona qué versión subir, la única forma de indicárselo es mediante el tag Version de nuestro proyecto mediante los siguientes formatos:

  • Versión en desarrollo: X.X.X-SNAPSHOT
  • Versión de distribución: X.X.X
<distributionManagement>
	<repository>
		<id>releases</id>
		<name>my-project-releases</name>
		<url>http://url_repo/artifactory/my-project-releases</url>
	</repository>
	<snapshotRepository>
		<id>snapshots</id>
		<name>my-project-snapshots</name>
		<url>http://url_repo/artifactory/my-project-snapshots</url>
	</snapshotRepository>
</distributionManagement>

 

 

CONFIGURAR LAS CREDENCIALES

Como sabemos, todo servicio suele estar vinculado a una cuenta. Por tanto, debemos establecer nuestro usuario y contraseña de acceso al repositorio para poder realizar el despliegue.

Siguiendo un modelo de buenas prácticas, Maven recomienda establecer estas credenciales en un fichero llamado settings.xml, Éste será el encargado de definir valores de configuración para ser usada en las ejecuciones (sin ser específicas) para un proyecto en concreto.

Los dos ámbitos que podemos encontrar son:

  • Maven. Será usado como configuración global su ubicación se encuentra en ${maven.home}/conf/settings.xml
  • Usuario. Será usado con la configuración establecida por el usuario su ubicación se encuentra en ${user.home}/.m2/settings.xml

Si es la primera vez que configuramos nuestro fichero como usuario, debemos crearlo e introducir las credenciales de la siguiente manera:

<settings xmlns="http://maven.apache.org/SETTINGS/1.0.0"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.0.0
	                    https://maven.apache.org/xsd/settings-1.0.0.xsd">
	<servers>
		<server>
			<id>releases</id>
			<username>admin</username>
			<password>password</password>
		</server>
		<server>
			<id>snapshots</id>
			<username>admin</username>
			<password>password</password>
		</server>
	</servers>
</settings>

Debemos tener muy en cuenta el ID que usemos ya que será el que asocie Maven automáticamente con los repositorios definidos anteriormente.

 

 

DESPLEGAR EL ARTEFACTO

Finalmente, teniendo todas las configuraciones establecidas, sólo nos resta desplegar el proyecto. Por tanto, procederemos a abrir un terminal y navegar hasta el directorio del proyecto de nuestro artefacto.

Una vez situados en él, simplemente convocamos el paso de despliegue de nuestro ciclo de vida para efectuar la construcción completa y finalmente la subida al repositorio de nuestro artefacto.

Usaremos la siguiente línea de comando:

$ mvn deploy

 

 

USAR EL ARTEFACTO

Una vez hayamos configurado correctamente el artefacto, podemos usarlo en proyectos. Para ello, debemos configurar el POM de nuestro nuevo proyecto añadiendo la dependencia de nuestro artefacto de la siguiente forma:

<dependency>
	<groupId>testing</groupId>
	<artifactId>my-project-deploy</artifactId>
	<version>1.0.0</version>
</dependency>

 

Esto nos permitirá un uso total de nuestro artefacto siempre y cuando nuestro repositorio sea público. En el caso contrario, debemos definir la ubicación de nuestros repositorios en nuestro proyecto para que entienda de dónde procede.

<repositories>
      <repository>
            <url>http://url_repo/artifactory/my-project-releases<</url>
            <releases>
                  <enabled>true</enabled>
            </releases>
            <snapshots>
                  <enabled>false</enabled>
            </snapshots>
      </repository>
	<repository>
	      <url>http://url_repo/artifactory/my-project-snapshots</url>
            <releases>
                  <enabled>false</enabled>
            </releases>
            <snapshots>
                  <enabled>true</enabled>
            </snapshots>
      </repository>
</repositories>

 

Hemos realizado un proyecto Maven con todas estas configuraciones de despliegue, para que puedas verlo en acción y utilizarlo como dependencia con tu proyecto si quieres. Podrás encontrarlo en nuestro repositorio de Github.

 

 


Cómo crear un arquetipo Maven desde un proyecto existente

Habitualmente, durante el ciclo de vida de los proyectos se desarrollan soluciones, herramientas y configuraciones que pueden ser objeto de reutilizarlos en próximas aventuras.

Para esto, cada equipo (o grupo de equipos gestionados) debe desarrollar un conjunto de elementos que se utilicen repetidamente con el fin de ofrecer productos más sólidos y de mayor calidad o abaratar los costes del desarrollo.

En otras palabras, se desarrolla una pila tecnológica en base a la experiencia y conocimientos adquiridos con la iteración de los proyectos. En Maven, para generar un nuevo proyecto que cumpla con las especificaciones o características propias de esa pila tecnológica utilizamos los arquetipos.

Conceptualmente un arquetipo es básicamente una plantilla. Es decir, un patrón o modelo original desde el que se generarán otros elementos del mismo tipo. En desarrollo nos apoyamos en los arquetipos para reutilizar código y arquitecturas.

El objetivo de este post es obtener un arquetipo Maven desde un proyecto existente y generar otro proyecto desde ese arquetipo para reutilizar código modificado.

Antes de empezar, este es el entorno utilizado para el tutorial:

  • Hardware: Intel® Core™ i7-7500U CPU @ 2.70GHz, 16GB de RAM
  • SO: Ubuntu 16.04 LTS
  • JDK8
  • Maven 3
  • Git 2.7.4

 

1. CLONAR UN PROYECTO EJEMPLO

Utilizaremos una guía de spring boot: https://github.com/spring-guides/gs-spring-boot

Clonamos el proyecto:

git clone https://github.com/spring-guides/gs-spring-boot.git

Lo probamos:

cd gs-spring-boot/initial/
mvn spring-boot:run

Abrimos un navegador web ¡y listo!

Arquetipo Maven - Ejecución Spring Boot - SDOS

 

2. MODIFICAR EL PROYECTO

Vamos a modificar el proyecto para que sea nuestro “modelo”. Para ello vamos a cambiar simplemente el mensaje de bienvenida que se encuentra en el archivo ~/gs-spring-boot/initial/src/main/java/hello/HelloController.java.

package hello;

import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.bind.annotation.RequestMapping;

@RestController
public class HelloController {
    
    @RequestMapping("/")
    public String index() {
        return "Hola arquetipo!!";
    }
    
}

¡Ahora sí!

Arquetipo Maven - Ejecución Modificación Proyecto - SDOS

 

 

3. GENERAR E INSTALAR EL ARQUETIPO

Para generar el arquetipo utilizaremos el Maven Archetype Plugin desde command line. El resultado será una plantilla con los mismos archivos del proyecto desde el cual hemos partido.

Lo primero que haremos es crear un archivo de propiedades para definir el Maven GAV (groupId, artifactId, version) para nuestro arquetipo customizado. Para ello crearemos el archivo ~/gs-spring-boot/initial/my_archetype.properties con el siguiente contenido:

archetype.groupId=es.sdos
archetype.artifactId=sdos-custom-archetype
archetype.package=es.sdos.ca
archetype.version=0.0.1
## groupId por defecto para proyectos generados a partir de este arquetipo
groupId=es.sdos
## artifactId por defecto para proyectos generados a partir de este arquetipo
artifactId=sdos-example

Y ejecutamos la siguiente sentencia:

cd ~/gs-spring-boot/initial
mvn clean archetype:create-from-project -Darchetype.properties="my_archetype.properties"

En este momento ya tenemos el proyecto de tipo arquetipo generado con todos los recursos presentes en el proyecto clonado inicialmente y posteriormente modificado. Vamos a instalarlo en el repositorio local:

cd ~/gs-spring-boot/initial/target/generated-sources/archetype/
mvn install

Arquetipo Maven - Instalación - SDOS

 

 

4. CREAR UN NUEVO PROYECTO

Para crear el proyecto, introducimos las siguientes sentencias:

mkdir /tmp/proyecto-prueba-workspace
cd /tmp/proyecto-prueba-workspace/
mvn archetype:generate -Dfilter=es.sdos:sdos-custom-archetype

La consola entrará en modo interactivo, enumerará la lista de arquetipos encontrados en los repositorios configurados otorgándoles un número ordinal. Por ejemplo:

Arquetipo Maven - Proyecto desde Arquetipo - SDOS

 

En nuestro caso, seleccionamos el número 1 o que el que corresponda a es.sdos:sdos-custom-archetype.

Ahora, seguirá preguntando las propiedades para el nuevo proyecto. Estas deben ser nuestras repuestas:

  • groupId: es.sdos
  • artifactId: ejemplo
  • version: 0.0.1-SNAPSHOT
  • package: es.sdos (o simplemente pulsamos “enter”)

En este punto nos solicitará una confirmación. Le decimos que sí (“Y”).

Arquetipo Maven - Confirmación Proyecto - SDOS

 

 

5. PROBAR EL PROYECTO

Finalmente, para probar el proyecto, ejecutamos las sentencias:

cd /tmp/proyecto-prueba-workspace/ejemplo/
mvn spring-boot:run

Arquetipo Maven - Ejecución Proyecto - SDOS

 

Con esto habríamos concluido. Al abrir el navegador, se desplegará un nuevo proyecto con nuestras modificaciones.

 

CONCLUSIONES

Después de modificar el código de un proyecto existente, hemos utilizado de manera rápida y eficaz el plugin de Maven Archetype para heredar esas modificaciones a través de un arquetipo.

Realmente, invirtiendo poco tiempo, podemos aprovechar cualquier proyecto disponible para utilizarlo de punto de partida en el futuro.

Puedes encontrar todo el código fuente aquí.

 


Uso de cookies

Este sitio web utiliza cookies para que tengas la mejor experiencia de usuario. Si continúas navegando estas dando tu consentimiento para la aceptación de las mencionadas cookies y la aceptación de nuestra política de cookies, pincha el enlace para obtener más información.

ACEPTAR
Aviso de cookies